pygcode API Reference
Python library for parsing, validating, and generating G-code for CNC machines and 3D printers.
pygcode.Block
Python Library Documentation: class Block in module pygcode.block class Block(builtins.object) | Block(text=None, verify=True) | | GCode block (effectively any gcode file line that defines any <word><value>) | | Methods defined here: | | __bool__(self) | | __getattr__(self, k) | | __init__(self, text=None, verify=True) | Block Constructor | :param A-Z: gcode parameter values | :param comment: comment text | | __len__(self) | Block length = number of identified gcodes (+ 1 if any modal parameters are defined) | :return: block length | | __nonzero__ = __bool__(self) | | __str__(self) | Return str(self). | | ---------------------------------------------------------------------- | Readonly properties defined here: | | text | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
pygcode.Comment
Python Library Documentation: class CommentBrackets in module pygcode.comment
class CommentBrackets(CommentBase)
| CommentBrackets(text)
|
| Comments of the format: 'G00 X1 Y2 (something profound)
|
| Method resolution order:
| CommentBrackets
| CommentBase
| builtins.object
|
| Methods defined here:
|
| __str__(self)
| Return str(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| AUTO_REGEX = re.compile('\\((?P<text>[^\\)]*)\\)')
|
| ORDER = 2
|
| ----------------------------------------------------------------------
| Methods inherited from CommentBase:
|
| __init__(self, text)
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from CommentBase:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from CommentBase:
|
| MULTICOMMENT_JOINER = '. '
pygcode.CoordinateSystem
Python Library Documentation: class CoordinateSystem in module pygcode.machine class CoordinateSystem(builtins.object) | CoordinateSystem(axes=None) | | Methods defined here: | | __copy__(self) | | __init__(self, axes=None) | Initialize self. See help(type(self)) for accurate signature. | | __repr__(self) | Return repr(self). | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
pygcode.GCode
Python Library Documentation: class GCode in module pygcode.gcodes
class GCode(builtins.object)
| GCode(*words, **params)
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
|
| default_word = None
|
| exec_order = 999
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeAbsoluteArcDistanceMode
Python Library Documentation: class GCodeAbsoluteArcDistanceMode in module pygcode.gcodes
class GCodeAbsoluteArcDistanceMode(GCodeDistanceMode)
| GCodeAbsoluteArcDistanceMode(*words, **params)
|
| G90.1: Absolute Distance Mode for Arc IJK Parameters
|
| Method resolution order:
| GCodeAbsoluteArcDistanceMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 4
|
| word_key = <Word: G90.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeAbsoluteDistanceMode
Python Library Documentation: class GCodeAbsoluteDistanceMode in module pygcode.gcodes
class GCodeAbsoluteDistanceMode(GCodeDistanceMode)
| GCodeAbsoluteDistanceMode(*words, **params)
|
| G90: Absolute Distance Mode
|
| Method resolution order:
| GCodeAbsoluteDistanceMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 3
|
| word_key = <Word: G90>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeAdaptiveFeed
Python Library Documentation: class GCodeAdaptiveFeed in module pygcode.gcodes
class GCodeAdaptiveFeed(GCodeOtherModal)
| GCodeAdaptiveFeed(*words, **params)
|
| M52: Adaptive Feed Control
|
| Method resolution order:
| GCodeAdaptiveFeed
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| param_letters = {'P'}
|
| word_key = <Word: M52>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeAddToolLengthOffset
Python Library Documentation: class GCodeAddToolLengthOffset in module pygcode.gcodes
class GCodeAddToolLengthOffset(GCodeToolLength)
| GCodeAddToolLengthOffset(*words, **params)
|
| G43.2: Appkly Additional Tool Length Offset
|
| Method resolution order:
| GCodeAddToolLengthOffset
| GCodeToolLength
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'H'}
|
| word_key = <Word: G43.2>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeToolLength:
|
| exec_order = 180
|
| modal_group = 8
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeAnalogOutput
Python Library Documentation: class GCodeAnalogOutput in module pygcode.gcodes
class GCodeAnalogOutput(GCodeIO)
| GCodeAnalogOutput(*words, **params)
|
| Analog Output
|
| Method resolution order:
| GCodeAnalogOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'T'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeAnalogOutputImmediate
Python Library Documentation: class GCodeAnalogOutputImmediate in module pygcode.gcodes
class GCodeAnalogOutputImmediate(GCodeAnalogOutput)
| GCodeAnalogOutputImmediate(*words, **params)
|
| M68: Analog Output, Immediate
|
| Method resolution order:
| GCodeAnalogOutputImmediate
| GCodeAnalogOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M68>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeAnalogOutput:
|
| param_letters = {'T'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeAnalogOutputSyncd
Python Library Documentation: class GCodeAnalogOutputSyncd in module pygcode.gcodes
class GCodeAnalogOutputSyncd(GCodeAnalogOutput)
| GCodeAnalogOutputSyncd(*words, **params)
|
| M67: Analog Output, Synchronized
|
| Method resolution order:
| GCodeAnalogOutputSyncd
| GCodeAnalogOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M67>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeAnalogOutput:
|
| param_letters = {'T'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeArcMove
Python Library Documentation: class GCodeArcMove in module pygcode.gcodes
class GCodeArcMove(GCodeMotion)
| GCodeArcMove(*words, **params)
|
| Arc Move
|
| Method resolution order:
| GCodeArcMove
| GCodeMotion
| GCode
| builtins.object
|
| Methods defined here:
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'I', 'J', 'K', ...}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeArcMoveCCW
Python Library Documentation: class GCodeArcMoveCCW in module pygcode.gcodes
class GCodeArcMoveCCW(GCodeArcMove)
| GCodeArcMoveCCW(*words, **params)
|
| G3: Arc Move (counter-clockwise)
|
| Method resolution order:
| GCodeArcMoveCCW
| GCodeArcMove
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G03>
|
| ----------------------------------------------------------------------
| Methods inherited from GCodeArcMove:
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeArcMove:
|
| param_letters = {'A', 'B', 'C', 'I', 'J', 'K', ...}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeArcMoveCW
Python Library Documentation: class GCodeArcMoveCW in module pygcode.gcodes
class GCodeArcMoveCW(GCodeArcMove)
| GCodeArcMoveCW(*words, **params)
|
| G2: Arc Move (clockwise)
|
| Method resolution order:
| GCodeArcMoveCW
| GCodeArcMove
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G02>
|
| ----------------------------------------------------------------------
| Methods inherited from GCodeArcMove:
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeArcMove:
|
| param_letters = {'A', 'B', 'C', 'I', 'J', 'K', ...}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeBoringCycleDwellFeedOut
Python Library Documentation: class GCodeBoringCycleDwellFeedOut in module pygcode.gcodes
class GCodeBoringCycleDwellFeedOut(GCodeCannedCycle)
| GCodeBoringCycleDwellFeedOut(*words, **params)
|
| G89: Boring Cycle, Dwell, Feed Out
|
| Method resolution order:
| GCodeBoringCycleDwellFeedOut
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'P', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'P', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G89>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeBoringCycleFeedOut
Python Library Documentation: class GCodeBoringCycleFeedOut in module pygcode.gcodes
class GCodeBoringCycleFeedOut(GCodeCannedCycle)
| GCodeBoringCycleFeedOut(*words, **params)
|
| G85: Boring Cycle, Feed Out
|
| Method resolution order:
| GCodeBoringCycleFeedOut
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'P', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'P', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G85>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCancelCannedCycle
Python Library Documentation: class GCodeCancelCannedCycle in module pygcode.gcodes
class GCodeCancelCannedCycle(GCodeMotion)
| GCodeCancelCannedCycle(*words, **params)
|
| G80: Cancel Canned Cycle
|
| Method resolution order:
| GCodeCancelCannedCycle
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 241
|
| modal_group = None
|
| word_key = <Word: G80>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| param_letters = {'A', 'B', 'C', 'U', 'V', 'W', ...}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCancelToolLengthOffset
Python Library Documentation: class GCodeCancelToolLengthOffset in module pygcode.gcodes
class GCodeCancelToolLengthOffset(GCodeToolLength)
| GCodeCancelToolLengthOffset(*words, **params)
|
| G49: Cancel Tool Length Compensation
|
| Method resolution order:
| GCodeCancelToolLengthOffset
| GCodeToolLength
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G49>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeToolLength:
|
| exec_order = 180
|
| modal_group = 8
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCannedCycle
Python Library Documentation: class GCodeCannedCycle in module pygcode.gcodes
class GCodeCannedCycle(GCode)
| GCodeCannedCycle(*words, **params)
|
| Method resolution order:
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 242
|
| modal_group = 1
|
| param_letters = {'U', 'V', 'W', 'X', 'Y', 'Z'}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCannedCycleReturnPrevLevel
Python Library Documentation: class GCodeCannedCycleReturnPrevLevel in module pygcode.gcodes
class GCodeCannedCycleReturnPrevLevel(GCodeCannedReturnMode)
| GCodeCannedCycleReturnPrevLevel(*words, **params)
|
| G98: Canned Cycle Return to the level set prior to cycle start
|
| Method resolution order:
| GCodeCannedCycleReturnPrevLevel
| GCodeCannedReturnMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G98>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedReturnMode:
|
| exec_order = 220
|
| modal_group = 10
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCannedCycleReturnToR
Python Library Documentation: class GCodeCannedCycleReturnToR in module pygcode.gcodes
class GCodeCannedCycleReturnToR(GCodeCannedReturnMode)
| GCodeCannedCycleReturnToR(*words, **params)
|
| G99: Canned Cycle Return to the level set by R
|
| Method resolution order:
| GCodeCannedCycleReturnToR
| GCodeCannedReturnMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G99>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedReturnMode:
|
| exec_order = 220
|
| modal_group = 10
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCannedReturnMode
Python Library Documentation: class GCodeCannedReturnMode in module pygcode.gcodes
class GCodeCannedReturnMode(GCode)
| GCodeCannedReturnMode(*words, **params)
|
| Method resolution order:
| GCodeCannedReturnMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 220
|
| modal_group = 10
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCoolant
Python Library Documentation: class GCodeCoolant in module pygcode.gcodes
class GCodeCoolant(GCode)
| GCodeCoolant(*words, **params)
|
| Method resolution order:
| GCodeCoolant
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 110
|
| modal_group = 108
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCoolantFloodOn
Python Library Documentation: class GCodeCoolantFloodOn in module pygcode.gcodes
class GCodeCoolantFloodOn(GCodeCoolant)
| GCodeCoolantFloodOn(*words, **params)
|
| M8: turn flood coolant on
|
| Method resolution order:
| GCodeCoolantFloodOn
| GCodeCoolant
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M08>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCoolant:
|
| exec_order = 110
|
| modal_group = 108
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCoolantMistOn
Python Library Documentation: class GCodeCoolantMistOn in module pygcode.gcodes
class GCodeCoolantMistOn(GCodeCoolant)
| GCodeCoolantMistOn(*words, **params)
|
| M7: turn mist coolant on
|
| Method resolution order:
| GCodeCoolantMistOn
| GCodeCoolant
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M07>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCoolant:
|
| exec_order = 110
|
| modal_group = 108
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCoolantOff
Python Library Documentation: class GCodeCoolantOff in module pygcode.gcodes
class GCodeCoolantOff(GCodeCoolant)
| GCodeCoolantOff(*words, **params)
|
| M9: turn all coolant off
|
| Method resolution order:
| GCodeCoolantOff
| GCodeCoolant
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M09>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCoolant:
|
| exec_order = 110
|
| modal_group = 108
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCoordSystemOffset
Python Library Documentation: class GCodeCoordSystemOffset in module pygcode.gcodes
class GCodeCoordSystemOffset(GCodeNonModal)
| GCodeCoordSystemOffset(*words, **params)
|
| G92: Coordinate System Offset
|
| Method resolution order:
| GCodeCoordSystemOffset
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 230
|
| word_key = <Word: G92>
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCublcSpline
Python Library Documentation: class GCodeCublcSpline in module pygcode.gcodes
class GCodeCublcSpline(GCodeMotion)
| GCodeCublcSpline(*words, **params)
|
| G5: Cubic Spline
|
| Method resolution order:
| GCodeCublcSpline
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'I', 'J', 'P', ...}
|
| word_key = <Word: G05>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCutterCompLeft
Python Library Documentation: class GCodeCutterCompLeft in module pygcode.gcodes
class GCodeCutterCompLeft(GCodeCutterRadiusComp)
| GCodeCutterCompLeft(*words, **params)
|
| G41: Cutter Radius Compensation (left)
|
| Method resolution order:
| GCodeCutterCompLeft
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D'}
|
| word_key = <Word: G41>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCutterRadiusComp:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCutterCompRight
Python Library Documentation: class GCodeCutterCompRight in module pygcode.gcodes
class GCodeCutterCompRight(GCodeCutterRadiusComp)
| GCodeCutterCompRight(*words, **params)
|
| G42: Cutter Radius Compensation (right)
|
| Method resolution order:
| GCodeCutterCompRight
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D'}
|
| word_key = <Word: G42>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCutterRadiusComp:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCutterRadiusComp
Python Library Documentation: class GCodeCutterRadiusComp in module pygcode.gcodes
class GCodeCutterRadiusComp(GCode)
| GCodeCutterRadiusComp(*words, **params)
|
| Method resolution order:
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeCutterRadiusCompOff
Python Library Documentation: class GCodeCutterRadiusCompOff in module pygcode.gcodes
class GCodeCutterRadiusCompOff(GCodeCutterRadiusComp)
| GCodeCutterRadiusCompOff(*words, **params)
|
| G40: Cutter Radius Compensation Off
|
| Method resolution order:
| GCodeCutterRadiusCompOff
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G40>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCutterRadiusComp:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDefinition
Python Library Documentation: class GCodeDefinition in module pygcode.gcodes
class GCodeDefinition(GCode)
| GCodeDefinition(*words, **params)
|
| Method resolution order:
| GCodeDefinition
| GCode
| builtins.object
|
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| exec_order = 999
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDigitalOutput
Python Library Documentation: class GCodeDigitalOutput in module pygcode.gcodes
class GCodeDigitalOutput(GCodeIO)
| GCodeDigitalOutput(*words, **params)
|
| Digital Output Control
|
| Method resolution order:
| GCodeDigitalOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'P'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDigitalOutputOff
Python Library Documentation: class GCodeDigitalOutputOff in module pygcode.gcodes
class GCodeDigitalOutputOff(GCodeDigitalOutput)
| GCodeDigitalOutputOff(*words, **params)
|
| M65: turn off digital output immediately
|
| Method resolution order:
| GCodeDigitalOutputOff
| GCodeDigitalOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M65>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDigitalOutput:
|
| param_letters = {'P'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDigitalOutputOffSyncd
Python Library Documentation: class GCodeDigitalOutputOffSyncd in module pygcode.gcodes
class GCodeDigitalOutputOffSyncd(GCodeDigitalOutput)
| GCodeDigitalOutputOffSyncd(*words, **params)
|
| M63: turn off digital output synchronized with motion
|
| Method resolution order:
| GCodeDigitalOutputOffSyncd
| GCodeDigitalOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M63>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDigitalOutput:
|
| param_letters = {'P'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDigitalOutputOn
Python Library Documentation: class GCodeDigitalOutputOn in module pygcode.gcodes
class GCodeDigitalOutputOn(GCodeDigitalOutput)
| GCodeDigitalOutputOn(*words, **params)
|
| M64: turn on digital output immediately
|
| Method resolution order:
| GCodeDigitalOutputOn
| GCodeDigitalOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M64>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDigitalOutput:
|
| param_letters = {'P'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDigitalOutputOnSyncd
Python Library Documentation: class GCodeDigitalOutputOnSyncd in module pygcode.gcodes
class GCodeDigitalOutputOnSyncd(GCodeDigitalOutput)
| GCodeDigitalOutputOnSyncd(*words, **params)
|
| M62: turn on digital output synchronized with motion
|
| Method resolution order:
| GCodeDigitalOutputOnSyncd
| GCodeDigitalOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M62>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDigitalOutput:
|
| param_letters = {'P'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDistanceMode
Python Library Documentation: class GCodeDistanceMode in module pygcode.gcodes
class GCodeDistanceMode(GCode)
| GCodeDistanceMode(*words, **params)
|
| Method resolution order:
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDrillingCycle
Python Library Documentation: class GCodeDrillingCycle in module pygcode.gcodes
class GCodeDrillingCycle(GCodeCannedCycle)
| GCodeDrillingCycle(*words, **params)
|
| G81: Drilling Cycle
|
| Method resolution order:
| GCodeDrillingCycle
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'P', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'P', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G81>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDrillingCycleChipBreaking
Python Library Documentation: class GCodeDrillingCycleChipBreaking in module pygcode.gcodes
class GCodeDrillingCycleChipBreaking(GCodeCannedCycle)
| GCodeDrillingCycleChipBreaking(*words, **params)
|
| G73: Drilling Cycle, ChipBreaking
|
| Method resolution order:
| GCodeDrillingCycleChipBreaking
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'Q', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'Q', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G73>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDrillingCycleDwell
Python Library Documentation: class GCodeDrillingCycleDwell in module pygcode.gcodes
class GCodeDrillingCycleDwell(GCodeCannedCycle)
| GCodeDrillingCycleDwell(*words, **params)
|
| G82: Drilling Cycle, Dwell
|
| Method resolution order:
| GCodeDrillingCycleDwell
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'P', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'P', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G82>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDrillingCyclePeck
Python Library Documentation: class GCodeDrillingCyclePeck in module pygcode.gcodes
class GCodeDrillingCyclePeck(GCodeCannedCycle)
| GCodeDrillingCyclePeck(*words, **params)
|
| G83: Drilling Cycle, Peck
|
| Method resolution order:
| GCodeDrillingCyclePeck
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'Q', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'Q', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G83>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDwell
Python Library Documentation: class GCodeDwell in module pygcode.gcodes
class GCodeDwell(GCodeMotion)
| GCodeDwell(*words, **params)
|
| G4: Dwell
|
| Method resolution order:
| GCodeDwell
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 140
|
| modal_group = None
|
| param_letters = {'P'}
|
| word_key = <Word: G04>
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDynamicCutterCompLeft
Python Library Documentation: class GCodeDynamicCutterCompLeft in module pygcode.gcodes
class GCodeDynamicCutterCompLeft(GCodeCutterRadiusComp)
| GCodeDynamicCutterCompLeft(*words, **params)
|
| G41.1: Dynamic Cutter Radius Compensation (left)
|
| Method resolution order:
| GCodeDynamicCutterCompLeft
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D', 'L'}
|
| word_key = <Word: G41.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCutterRadiusComp:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDynamicCutterCompRight
Python Library Documentation: class GCodeDynamicCutterCompRight in module pygcode.gcodes
class GCodeDynamicCutterCompRight(GCodeCutterRadiusComp)
| GCodeDynamicCutterCompRight(*words, **params)
|
| G42.1: Dynamic Cutter Radius Compensation (right)
|
| Method resolution order:
| GCodeDynamicCutterCompRight
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D', 'L'}
|
| word_key = <Word: G42.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCutterRadiusComp:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeDynamicToolLengthOffset
Python Library Documentation: class GCodeDynamicToolLengthOffset in module pygcode.gcodes
class GCodeDynamicToolLengthOffset(GCodeToolLength)
| GCodeDynamicToolLengthOffset(*words, **params)
|
| G43.1: Dynamic Tool Length Offset
|
| Method resolution order:
| GCodeDynamicToolLengthOffset
| GCodeToolLength
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G43.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeToolLength:
|
| exec_order = 180
|
| modal_group = 8
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeEndProgram
Python Library Documentation: class GCodeEndProgram in module pygcode.gcodes
class GCodeEndProgram(GCodeProgramControl)
| GCodeEndProgram(*words, **params)
|
| M2: Program End
|
| Method resolution order:
| GCodeEndProgram
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M02>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeProgramControl:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeEndProgramPalletShuttle
Python Library Documentation: class GCodeEndProgramPalletShuttle in module pygcode.gcodes
class GCodeEndProgramPalletShuttle(GCodeProgramControl)
| GCodeEndProgramPalletShuttle(*words, **params)
|
| M30: exchange pallet shuttles and end the program
|
| Method resolution order:
| GCodeEndProgramPalletShuttle
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M30>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeProgramControl:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeExactPathMode
Python Library Documentation: class GCodeExactPathMode in module pygcode.gcodes
class GCodeExactPathMode(GCodePathControlMode)
| GCodeExactPathMode(*words, **params)
|
| G61: Exact path mode
|
| Method resolution order:
| GCodeExactPathMode
| GCodePathControlMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G61>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePathControlMode:
|
| exec_order = 200
|
| modal_group = 13
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeExactStopMode
Python Library Documentation: class GCodeExactStopMode in module pygcode.gcodes
class GCodeExactStopMode(GCodePathControlMode)
| GCodeExactStopMode(*words, **params)
|
| G61.1: Exact stop mode
|
| Method resolution order:
| GCodeExactStopMode
| GCodePathControlMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G61.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePathControlMode:
|
| exec_order = 200
|
| modal_group = 13
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeFeedOverride
Python Library Documentation: class GCodeFeedOverride in module pygcode.gcodes
class GCodeFeedOverride(GCodeOtherModal)
| GCodeFeedOverride(*words, **params)
|
| M50: Feed Override Control
|
| Method resolution order:
| GCodeFeedOverride
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| param_letters = {'P'}
|
| word_key = <Word: M50>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeFeedRate
Python Library Documentation: class GCodeFeedRate in module pygcode.gcodes
class GCodeFeedRate(GCodeOtherModal)
| GCodeFeedRate(*words, **params)
|
| F: Set Feed Rate
|
| Method resolution order:
| GCodeFeedRate
| GCodeOtherModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: F0>
|
| exec_order = 40
|
| modal_group = 201
|
| word_letter = 'F'
|
| word_value_configurable = True
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
pygcode.GCodeFeedRateMode
Python Library Documentation: class GCodeFeedRateMode in module pygcode.gcodes
class GCodeFeedRateMode(GCode)
| GCodeFeedRateMode(*words, **params)
|
| Method resolution order:
| GCodeFeedRateMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 30
|
| modal_group = 5
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeFeedStop
Python Library Documentation: class GCodeFeedStop in module pygcode.gcodes
class GCodeFeedStop(GCodeOtherModal)
| GCodeFeedStop(*words, **params)
|
| M53: Feed Stop Control
|
| Method resolution order:
| GCodeFeedStop
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| param_letters = {'P'}
|
| word_key = <Word: M53>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeGotoPredefinedPosition
Python Library Documentation: class GCodeGotoPredefinedPosition in module pygcode.gcodes
class GCodeGotoPredefinedPosition(GCodeNonModal)
| GCodeGotoPredefinedPosition(*words, **params)
|
| G28,G30: Goto Predefined Position (rapid movement)
|
| Method resolution order:
| GCodeGotoPredefinedPosition
| GCodeNonModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: G28>
|
| exec_order = 230
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_value_configurable = False
pygcode.GCodeIO
Python Library Documentation: class GCodeIO in module pygcode.gcodes
class GCodeIO(GCode)
| GCodeIO(*words, **params)
|
| Method resolution order:
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeIncrementalArcDistanceMode
Python Library Documentation: class GCodeIncrementalArcDistanceMode in module pygcode.gcodes
class GCodeIncrementalArcDistanceMode(GCodeDistanceMode)
| GCodeIncrementalArcDistanceMode(*words, **params)
|
| G91.1: Incremental Distance Mode for Arc IJK Parameters
|
| Method resolution order:
| GCodeIncrementalArcDistanceMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 4
|
| word_key = <Word: G91.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeIncrementalDistanceMode
Python Library Documentation: class GCodeIncrementalDistanceMode in module pygcode.gcodes
class GCodeIncrementalDistanceMode(GCodeDistanceMode)
| GCodeIncrementalDistanceMode(*words, **params)
|
| G91: Incremental Distance Mode
|
| Method resolution order:
| GCodeIncrementalDistanceMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 3
|
| word_key = <Word: G91>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeInverseTimeMode
Python Library Documentation: class GCodeInverseTimeMode in module pygcode.gcodes
class GCodeInverseTimeMode(GCodeFeedRateMode)
| GCodeInverseTimeMode(*words, **params)
|
| G93: Inverse Time Mode
|
| Method resolution order:
| GCodeInverseTimeMode
| GCodeFeedRateMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G93>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeFeedRateMode:
|
| exec_order = 30
|
| modal_group = 5
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeLatheDiameterMode
Python Library Documentation: class GCodeLatheDiameterMode in module pygcode.gcodes
class GCodeLatheDiameterMode(GCodeDistanceMode)
| GCodeLatheDiameterMode(*words, **params)
|
| G7: Lathe Diameter Mode
|
| Method resolution order:
| GCodeLatheDiameterMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 15
|
| word_key = <Word: G07>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeLatheRadiusMode
Python Library Documentation: class GCodeLatheRadiusMode in module pygcode.gcodes
class GCodeLatheRadiusMode(GCodeDistanceMode)
| GCodeLatheRadiusMode(*words, **params)
|
| G8: Lathe Radius Mode
|
| Method resolution order:
| GCodeLatheRadiusMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 15
|
| word_key = <Word: G08>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeLineNumber
Python Library Documentation: class GCodeLineNumber in module pygcode.gcodes
class GCodeLineNumber(GCodeDefinition)
| GCodeLineNumber(*words, **params)
|
| N: Line Number
|
| Method resolution order:
| GCodeLineNumber
| GCodeDefinition
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| number
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| exec_order = 0
|
| word_letter = 'N'
|
| word_value_configurable = True
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
pygcode.GCodeLinearMove
Python Library Documentation: class GCodeLinearMove in module pygcode.gcodes
class GCodeLinearMove(GCodeMotion)
| GCodeLinearMove(*words, **params)
|
| G1: Linear Move
|
| Method resolution order:
| GCodeLinearMove
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G01>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| param_letters = {'A', 'B', 'C', 'U', 'V', 'W', ...}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeMotion
Python Library Documentation: class GCodeMotion in module pygcode.gcodes
class GCodeMotion(GCode)
| GCodeMotion(*words, **params)
|
| Method resolution order:
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 242
|
| modal_group = 1
|
| param_letters = {'A', 'B', 'C', 'U', 'V', 'W', ...}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeMoveInMachineCoords
Python Library Documentation: class GCodeMoveInMachineCoords in module pygcode.gcodes
class GCodeMoveInMachineCoords(GCodeNonModal)
| GCodeMoveInMachineCoords(*words, **params)
|
| G53: Move in Machine Coordinates
|
| Method resolution order:
| GCodeMoveInMachineCoords
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 240
|
| word_key = <Word: G53>
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeNURBS
Python Library Documentation: class GCodeNURBS in module pygcode.gcodes
class GCodeNURBS(GCodeMotion)
| GCodeNURBS(*words, **params)
|
| G5.2: Non-uniform rational basis spline (NURBS)
|
| Method resolution order:
| GCodeNURBS
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'L', 'P', 'U', ...}
|
| word_key = <Word: G05.2>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeNURBSEnd
Python Library Documentation: class GCodeNURBSEnd in module pygcode.gcodes
class GCodeNURBSEnd(GCodeNURBS)
| GCodeNURBSEnd(*words, **params)
|
| G5.3: end NURBS mode
|
| Method resolution order:
| GCodeNURBSEnd
| GCodeNURBS
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G05.3>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeNURBS:
|
| param_letters = {'A', 'B', 'C', 'L', 'P', 'U', ...}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeNonModal
Python Library Documentation: class GCodeNonModal in module pygcode.gcodes
class GCodeNonModal(GCode)
| GCodeNonModal(*words, **params)
|
| Method resolution order:
| GCodeNonModal
| GCode
| builtins.object
|
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| exec_order = 999
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeOrientSpindle
Python Library Documentation: class GCodeOrientSpindle in module pygcode.gcodes
class GCodeOrientSpindle(GCodeSpindle)
| GCodeOrientSpindle(*words, **params)
|
| M19: Orient Spindle
|
| Method resolution order:
| GCodeOrientSpindle
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M19>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeOtherModal
Python Library Documentation: class GCodeOtherModal in module pygcode.gcodes
class GCodeOtherModal(GCode)
| GCodeOtherModal(*words, **params)
|
| Method resolution order:
| GCodeOtherModal
| GCode
| builtins.object
|
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| exec_order = 999
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodePalletChangePause
Python Library Documentation: class GCodePalletChangePause in module pygcode.gcodes
class GCodePalletChangePause(GCodeProgramControl)
| GCodePalletChangePause(*words, **params)
|
| M60: Pallet Change Pause
|
| Method resolution order:
| GCodePalletChangePause
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M60>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeProgramControl:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodePathBlendingMode
Python Library Documentation: class GCodePathBlendingMode in module pygcode.gcodes
class GCodePathBlendingMode(GCodePathControlMode)
| GCodePathBlendingMode(*words, **params)
|
| G64: Path Blending
|
| Method resolution order:
| GCodePathBlendingMode
| GCodePathControlMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'P', 'Q'}
|
| word_key = <Word: G64>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePathControlMode:
|
| exec_order = 200
|
| modal_group = 13
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodePathControlMode
Python Library Documentation: class GCodePathControlMode in module pygcode.gcodes
class GCodePathControlMode(GCode)
| GCodePathControlMode(*words, **params)
|
| Method resolution order:
| GCodePathControlMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 200
|
| modal_group = 13
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodePauseProgram
Python Library Documentation: class GCodePauseProgram in module pygcode.gcodes
class GCodePauseProgram(GCodeProgramControl)
| GCodePauseProgram(*words, **params)
|
| M0: Program Pause
|
| Method resolution order:
| GCodePauseProgram
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M00>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeProgramControl:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodePauseProgramOptional
Python Library Documentation: class GCodePauseProgramOptional in module pygcode.gcodes
class GCodePauseProgramOptional(GCodeProgramControl)
| GCodePauseProgramOptional(*words, **params)
|
| M1: Program Pause (optional)
|
| Method resolution order:
| GCodePauseProgramOptional
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M01>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeProgramControl:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodePlaneSelect
Python Library Documentation: class GCodePlaneSelect in module pygcode.gcodes
class GCodePlaneSelect(GCode)
| GCodePlaneSelect(*words, **params)
|
| Method resolution order:
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 150
|
| modal_group = 2
|
| normal = None
|
| normal_axis = None
|
| plane_axes = set()
|
| quat = None
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeProgramControl
Python Library Documentation: class GCodeProgramControl in module pygcode.gcodes
class GCodeProgramControl(GCode)
| GCodeProgramControl(*words, **params)
|
| Method resolution order:
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeProgramName
Python Library Documentation: class GCodeProgramName in module pygcode.gcodes
class GCodeProgramName(GCodeDefinition)
| GCodeProgramName(*words, **params)
|
| O: Program Name
|
| Method resolution order:
| GCodeProgramName
| GCodeDefinition
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| name
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| exec_order = 1
|
| word_letter = 'O'
|
| word_value_configurable = True
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
pygcode.GCodeQuadraticSpline
Python Library Documentation: class GCodeQuadraticSpline in module pygcode.gcodes
class GCodeQuadraticSpline(GCodeMotion)
| GCodeQuadraticSpline(*words, **params)
|
| G5.1: Quadratic Spline
|
| Method resolution order:
| GCodeQuadraticSpline
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'I', 'J', 'U', ...}
|
| word_key = <Word: G05.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeRapidMove
Python Library Documentation: class GCodeRapidMove in module pygcode.gcodes
class GCodeRapidMove(GCodeMotion)
| GCodeRapidMove(*words, **params)
|
| G0: Rapid Move
|
| Method resolution order:
| GCodeRapidMove
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G00>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| param_letters = {'A', 'B', 'C', 'U', 'V', 'W', ...}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeResetCoordSystemOffset
Python Library Documentation: class GCodeResetCoordSystemOffset in module pygcode.gcodes
class GCodeResetCoordSystemOffset(GCodeNonModal)
| GCodeResetCoordSystemOffset(*words, **params)
|
| G92.1,G92.2: Reset Coordinate System Offset
|
| Method resolution order:
| GCodeResetCoordSystemOffset
| GCodeNonModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: G92.1>
|
| exec_order = 230
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_value_configurable = False
pygcode.GCodeRestoreCoordSystemOffset
Python Library Documentation: class GCodeRestoreCoordSystemOffset in module pygcode.gcodes
class GCodeRestoreCoordSystemOffset(GCodeNonModal)
| GCodeRestoreCoordSystemOffset(*words, **params)
|
| G92.3: Restore Coordinate System Offset
|
| Method resolution order:
| GCodeRestoreCoordSystemOffset
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 230
|
| word_key = <Word: G92.3>
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeRigidTapping
Python Library Documentation: class GCodeRigidTapping in module pygcode.gcodes
class GCodeRigidTapping(GCodeMotion)
| GCodeRigidTapping(*words, **params)
|
| G33.1: Rigid Tapping
|
| Method resolution order:
| GCodeRigidTapping
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'K', 'U', 'V', ...}
|
| word_key = <Word: G33.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectCoordinateSystem
Python Library Documentation: class GCodeSelectCoordinateSystem in module pygcode.gcodes
class GCodeSelectCoordinateSystem(GCodeOtherModal)
| GCodeSelectCoordinateSystem(*words, **params)
|
| Select Coordinate System
|
| Method resolution order:
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = None
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectCoordinateSystem1
Python Library Documentation: class GCodeSelectCoordinateSystem1 in module pygcode.gcodes
class GCodeSelectCoordinateSystem1(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem1(*words, **params)
|
| Select Coordinate System 1
|
| Method resolution order:
| GCodeSelectCoordinateSystem1
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 1
|
| word_key = <Word: G54>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectCoordinateSystem2
Python Library Documentation: class GCodeSelectCoordinateSystem2 in module pygcode.gcodes
class GCodeSelectCoordinateSystem2(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem2(*words, **params)
|
| Select Coordinate System 2
|
| Method resolution order:
| GCodeSelectCoordinateSystem2
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 2
|
| word_key = <Word: G55>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectCoordinateSystem3
Python Library Documentation: class GCodeSelectCoordinateSystem3 in module pygcode.gcodes
class GCodeSelectCoordinateSystem3(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem3(*words, **params)
|
| Select Coordinate System 3
|
| Method resolution order:
| GCodeSelectCoordinateSystem3
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 3
|
| word_key = <Word: G56>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectCoordinateSystem4
Python Library Documentation: class GCodeSelectCoordinateSystem4 in module pygcode.gcodes
class GCodeSelectCoordinateSystem4(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem4(*words, **params)
|
| Select Coordinate System 4
|
| Method resolution order:
| GCodeSelectCoordinateSystem4
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 4
|
| word_key = <Word: G57>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectCoordinateSystem5
Python Library Documentation: class GCodeSelectCoordinateSystem5 in module pygcode.gcodes
class GCodeSelectCoordinateSystem5(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem5(*words, **params)
|
| Select Coordinate System 5
|
| Method resolution order:
| GCodeSelectCoordinateSystem5
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 5
|
| word_key = <Word: G58>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectCoordinateSystem6
Python Library Documentation: class GCodeSelectCoordinateSystem6 in module pygcode.gcodes
class GCodeSelectCoordinateSystem6(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem6(*words, **params)
|
| Select Coordinate System 6
|
| Method resolution order:
| GCodeSelectCoordinateSystem6
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 6
|
| word_key = <Word: G59>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectCoordinateSystem7
Python Library Documentation: class GCodeSelectCoordinateSystem7 in module pygcode.gcodes
class GCodeSelectCoordinateSystem7(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem7(*words, **params)
|
| Select Coordinate System 7
|
| Method resolution order:
| GCodeSelectCoordinateSystem7
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 7
|
| word_key = <Word: G59.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectCoordinateSystem8
Python Library Documentation: class GCodeSelectCoordinateSystem8 in module pygcode.gcodes
class GCodeSelectCoordinateSystem8(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem8(*words, **params)
|
| Select Coordinate System 8
|
| Method resolution order:
| GCodeSelectCoordinateSystem8
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 8
|
| word_key = <Word: G59.2>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectCoordinateSystem9
Python Library Documentation: class GCodeSelectCoordinateSystem9 in module pygcode.gcodes
class GCodeSelectCoordinateSystem9(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem9(*words, **params)
|
| Select Coordinate System 9
|
| Method resolution order:
| GCodeSelectCoordinateSystem9
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 9
|
| word_key = <Word: G59.3>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectTool
Python Library Documentation: class GCodeSelectTool in module pygcode.gcodes
class GCodeSelectTool(GCodeOtherModal)
| GCodeSelectTool(*words, **params)
|
| T: Select Tool
|
| Method resolution order:
| GCodeSelectTool
| GCodeOtherModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: T0>
|
| exec_order = 60
|
| modal_group = 203
|
| word_letter = 'T'
|
| word_value_configurable = True
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
pygcode.GCodeSelectUVPlane
Python Library Documentation: class GCodeSelectUVPlane in module pygcode.gcodes
class GCodeSelectUVPlane(GCodePlaneSelect)
| GCodeSelectUVPlane(*words, **params)
|
| G17.1: select UV plane
|
| Method resolution order:
| GCodeSelectUVPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G17.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| normal = None
|
| normal_axis = None
|
| plane_axes = set()
|
| quat = None
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectVWPlane
Python Library Documentation: class GCodeSelectVWPlane in module pygcode.gcodes
class GCodeSelectVWPlane(GCodePlaneSelect)
| GCodeSelectVWPlane(*words, **params)
|
| G19.1: select VW plane
|
| Method resolution order:
| GCodeSelectVWPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G19.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| normal = None
|
| normal_axis = None
|
| plane_axes = set()
|
| quat = None
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectWUPlane
Python Library Documentation: class GCodeSelectWUPlane in module pygcode.gcodes
class GCodeSelectWUPlane(GCodePlaneSelect)
| GCodeSelectWUPlane(*words, **params)
|
| G18.1: select WU plane
|
| Method resolution order:
| GCodeSelectWUPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G18.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| normal = None
|
| normal_axis = None
|
| plane_axes = set()
|
| quat = None
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectXYPlane
Python Library Documentation: class GCodeSelectXYPlane in module pygcode.gcodes
class GCodeSelectXYPlane(GCodePlaneSelect)
| GCodeSelectXYPlane(*words, **params)
|
| G17: select XY plane (default)
|
| Method resolution order:
| GCodeSelectXYPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| normal = Vector3(0.00, 0.00, 1.00)
|
| normal_axis = 'Z'
|
| plane_axes = {'X', 'Y'}
|
| quat = Quaternion(real=1.00, imag=<0.00, 0.00, 0.00>)
|
| word_key = <Word: G17>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectYZPlane
Python Library Documentation: class GCodeSelectYZPlane in module pygcode.gcodes
class GCodeSelectYZPlane(GCodePlaneSelect)
| GCodeSelectYZPlane(*words, **params)
|
| G19: select YZ plane
|
| Method resolution order:
| GCodeSelectYZPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| normal = Vector3(1.00, 0.00, 0.00)
|
| normal_axis = 'X'
|
| plane_axes = {'Y', 'Z'}
|
| quat = Quaternion(real=0.50, imag=<0.50, 0.50, 0.50>)
|
| word_key = <Word: G19>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSelectZXPlane
Python Library Documentation: class GCodeSelectZXPlane in module pygcode.gcodes
class GCodeSelectZXPlane(GCodePlaneSelect)
| GCodeSelectZXPlane(*words, **params)
|
| G18: select ZX plane
|
| Method resolution order:
| GCodeSelectZXPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| normal = Vector3(0.00, 1.00, 0.00)
|
| normal_axis = 'Y'
|
| plane_axes = {'X', 'Z'}
|
| quat = Quaternion(real=0.50, imag=<-0.50, -0.50, -0.50>)
|
| word_key = <Word: G18>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSet
Python Library Documentation: class GCodeSet in module pygcode.gcodes
class GCodeSet(GCodeNonModal)
| GCodeSet(*words, **params)
|
| G10: Set stuff
|
| Method resolution order:
| GCodeSet
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 230
|
| param_letters = {'A', 'B', 'C', 'L', 'P', 'Q', ...}
|
| word_key = <Word: G10>
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSetPredefinedPosition
Python Library Documentation: class GCodeSetPredefinedPosition in module pygcode.gcodes
class GCodeSetPredefinedPosition(GCodeNonModal)
| GCodeSetPredefinedPosition(*words, **params)
|
| G28.1,G30.1: Set Predefined Position
|
| Method resolution order:
| GCodeSetPredefinedPosition
| GCodeNonModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: G28.1>
|
| exec_order = 230
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_value_configurable = False
pygcode.GCodeSpeedAndFeedOverrideOff
Python Library Documentation: class GCodeSpeedAndFeedOverrideOff in module pygcode.gcodes
class GCodeSpeedAndFeedOverrideOff(GCodeOtherModal)
| GCodeSpeedAndFeedOverrideOff(*words, **params)
|
| M49: Speed and Feed Override Control Off
|
| Method resolution order:
| GCodeSpeedAndFeedOverrideOff
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| modal_group = 109
|
| word_key = <Word: M49>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSpeedAndFeedOverrideOn
Python Library Documentation: class GCodeSpeedAndFeedOverrideOn in module pygcode.gcodes
class GCodeSpeedAndFeedOverrideOn(GCodeOtherModal)
| GCodeSpeedAndFeedOverrideOn(*words, **params)
|
| M48: Speed and Feed Override Control On
|
| Method resolution order:
| GCodeSpeedAndFeedOverrideOn
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| modal_group = 109
|
| word_key = <Word: M48>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSpindle
Python Library Documentation: class GCodeSpindle in module pygcode.gcodes
class GCodeSpindle(GCode)
| GCodeSpindle(*words, **params)
|
| Method resolution order:
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSpindleConstantSurfaceSpeedMode
Python Library Documentation: class GCodeSpindleConstantSurfaceSpeedMode in module pygcode.gcodes
class GCodeSpindleConstantSurfaceSpeedMode(GCodeSpindleSpeedMode)
| GCodeSpindleConstantSurfaceSpeedMode(*words, **params)
|
| G96: Spindle Constant Surface Speed
|
| Method resolution order:
| GCodeSpindleConstantSurfaceSpeedMode
| GCodeSpindleSpeedMode
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D', 'S'}
|
| word_key = <Word: G96>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindleSpeedMode:
|
| modal_group = 14
|
| word_letter = 'G'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSpindleRPMMode
Python Library Documentation: class GCodeSpindleRPMMode in module pygcode.gcodes
class GCodeSpindleRPMMode(GCodeSpindleSpeedMode)
| GCodeSpindleRPMMode(*words, **params)
|
| G97: Spindle RPM Speed
|
| Method resolution order:
| GCodeSpindleRPMMode
| GCodeSpindleSpeedMode
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D'}
|
| word_key = <Word: G97>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindleSpeedMode:
|
| modal_group = 14
|
| word_letter = 'G'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSpindleSpeed
Python Library Documentation: class GCodeSpindleSpeed in module pygcode.gcodes
class GCodeSpindleSpeed(GCodeOtherModal)
| GCodeSpindleSpeed(*words, **params)
|
| S: Set Spindle Speed
|
| Method resolution order:
| GCodeSpindleSpeed
| GCodeOtherModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: S0>
|
| exec_order = 50
|
| modal_group = 202
|
| word_letter = 'S'
|
| word_value_configurable = True
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
pygcode.GCodeSpindleSpeedMode
Python Library Documentation: class GCodeSpindleSpeedMode in module pygcode.gcodes
class GCodeSpindleSpeedMode(GCodeSpindle)
| GCodeSpindleSpeedMode(*words, **params)
|
| Method resolution order:
| GCodeSpindleSpeedMode
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 14
|
| word_letter = 'G'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSpindleSpeedOverride
Python Library Documentation: class GCodeSpindleSpeedOverride in module pygcode.gcodes
class GCodeSpindleSpeedOverride(GCodeOtherModal)
| GCodeSpindleSpeedOverride(*words, **params)
|
| M51: Spindle Speed Override Control
|
| Method resolution order:
| GCodeSpindleSpeedOverride
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| param_letters = {'P'}
|
| word_key = <Word: M51>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeSpindleSyncMotion
Python Library Documentation: class GCodeSpindleSyncMotion in module pygcode.gcodes
class GCodeSpindleSyncMotion(GCodeMotion)
| GCodeSpindleSyncMotion(*words, **params)
|
| G33: Spindle Synchronized Motion
|
| Method resolution order:
| GCodeSpindleSyncMotion
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'K', 'U', 'V', ...}
|
| word_key = <Word: G33>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeStartSpindle
Python Library Documentation: class GCodeStartSpindle in module pygcode.gcodes
class GCodeStartSpindle(GCodeSpindle)
| GCodeStartSpindle(*words, **params)
|
| M3,M4: Start Spindle Clockwise
|
| Method resolution order:
| GCodeStartSpindle
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 107
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeStartSpindleCCW
Python Library Documentation: class GCodeStartSpindleCCW in module pygcode.gcodes
class GCodeStartSpindleCCW(GCodeStartSpindle)
| GCodeStartSpindleCCW(*words, **params)
|
| M4: Start Spindle Counter-Clockwise
|
| Method resolution order:
| GCodeStartSpindleCCW
| GCodeStartSpindle
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M04>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeStartSpindle:
|
| modal_group = 107
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeStartSpindleCW
Python Library Documentation: class GCodeStartSpindleCW in module pygcode.gcodes
class GCodeStartSpindleCW(GCodeStartSpindle)
| GCodeStartSpindleCW(*words, **params)
|
| M3: Start Spindle Clockwise
|
| Method resolution order:
| GCodeStartSpindleCW
| GCodeStartSpindle
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M03>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeStartSpindle:
|
| modal_group = 107
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeStopSpindle
Python Library Documentation: class GCodeStopSpindle in module pygcode.gcodes
class GCodeStopSpindle(GCodeSpindle)
| GCodeStopSpindle(*words, **params)
|
| M5: Stop Spindle
|
| Method resolution order:
| GCodeStopSpindle
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 107
|
| word_key = <Word: M05>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeStraightProbe
Python Library Documentation: class GCodeStraightProbe in module pygcode.gcodes
class GCodeStraightProbe(GCodeMotion)
| GCodeStraightProbe(*words, **params)
|
| G38.2-G38.5: Straight Probe
|
| Method resolution order:
| GCodeStraightProbe
| GCodeMotion
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: G38.2>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| param_letters = {'A', 'B', 'C', 'U', 'V', 'W', ...}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_value_configurable = False
pygcode.GCodeThreadingCycle
Python Library Documentation: class GCodeThreadingCycle in module pygcode.gcodes
class GCodeThreadingCycle(GCodeCannedCycle)
| GCodeThreadingCycle(*words, **params)
|
| G76: Threading Cycle
|
| Method resolution order:
| GCodeThreadingCycle
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'E', 'H', 'I', 'J', 'K', 'L', ...}
|
| word_key = <Word: G76>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeToolChange
Python Library Documentation: class GCodeToolChange in module pygcode.gcodes
class GCodeToolChange(GCodeNonModal)
| GCodeToolChange(*words, **params)
|
| M6: Tool Change
|
| Method resolution order:
| GCodeToolChange
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 80
|
| param_letters = {'T'}
|
| word_key = <Word: M06>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeToolLength
Python Library Documentation: class GCodeToolLength in module pygcode.gcodes
class GCodeToolLength(GCode)
| GCodeToolLength(*words, **params)
|
| Method resolution order:
| GCodeToolLength
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 180
|
| modal_group = 8
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeToolLengthOffset
Python Library Documentation: class GCodeToolLengthOffset in module pygcode.gcodes
class GCodeToolLengthOffset(GCodeToolLength)
| GCodeToolLengthOffset(*words, **params)
|
| G43: Tool Length Offset
|
| Method resolution order:
| GCodeToolLengthOffset
| GCodeToolLength
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'H'}
|
| word_key = <Word: G43>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeToolLength:
|
| exec_order = 180
|
| modal_group = 8
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeToolSetCurrent
Python Library Documentation: class GCodeToolSetCurrent in module pygcode.gcodes
class GCodeToolSetCurrent(GCodeNonModal)
| GCodeToolSetCurrent(*words, **params)
|
| M61: Set Current Tool
|
| Method resolution order:
| GCodeToolSetCurrent
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 80
|
| param_letters = {'Q'}
|
| word_key = <Word: M61>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeUnit
Python Library Documentation: class GCodeUnit in module pygcode.gcodes
class GCodeUnit(GCode)
| GCodeUnit(*words, **params)
|
| Method resolution order:
| GCodeUnit
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 160
|
| modal_group = 6
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeUnitsPerMinuteMode
Python Library Documentation: class GCodeUnitsPerMinuteMode in module pygcode.gcodes
class GCodeUnitsPerMinuteMode(GCodeFeedRateMode)
| GCodeUnitsPerMinuteMode(*words, **params)
|
| G94: Units Per MinuteMode
|
| Method resolution order:
| GCodeUnitsPerMinuteMode
| GCodeFeedRateMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G94>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeFeedRateMode:
|
| exec_order = 30
|
| modal_group = 5
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeUnitsPerRevolution
Python Library Documentation: class GCodeUnitsPerRevolution in module pygcode.gcodes
class GCodeUnitsPerRevolution(GCodeFeedRateMode)
| GCodeUnitsPerRevolution(*words, **params)
|
| G95: Units Per Revolution
|
| Method resolution order:
| GCodeUnitsPerRevolution
| GCodeFeedRateMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G95>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeFeedRateMode:
|
| exec_order = 30
|
| modal_group = 5
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeUseInches
Python Library Documentation: class GCodeUseInches in module pygcode.gcodes
class GCodeUseInches(GCodeUnit)
| GCodeUseInches(*words, **params)
|
| G20: use inches for length units
|
| Method resolution order:
| GCodeUseInches
| GCodeUnit
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| unit_id = 0
|
| word_key = <Word: G20>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeUnit:
|
| exec_order = 160
|
| modal_group = 6
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeUseMillimeters
Python Library Documentation: class GCodeUseMillimeters in module pygcode.gcodes
class GCodeUseMillimeters(GCodeUnit)
| GCodeUseMillimeters(*words, **params)
|
| G21: use millimeters for length units
|
| Method resolution order:
| GCodeUseMillimeters
| GCodeUnit
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| unit_id = 1
|
| word_key = <Word: G21>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeUnit:
|
| exec_order = 160
|
| modal_group = 6
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeUserDefined
Python Library Documentation: class GCodeUserDefined in module pygcode.gcodes
class GCodeUserDefined(GCodeNonModal)
| GCodeUserDefined(*words, **params)
|
| M101-M199: User Defined Commands
|
| Method resolution order:
| GCodeUserDefined
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 130
|
| modal_group = 110
|
| param_letters = {'P', 'Q'}
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.GCodeWaitOnInput
Python Library Documentation: class GCodeWaitOnInput in module pygcode.gcodes
class GCodeWaitOnInput(GCodeIO)
| GCodeWaitOnInput(*words, **params)
|
| M66: Wait on Input
|
| Method resolution order:
| GCodeWaitOnInput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'E', 'L', 'P', 'Q'}
|
| word_key = <Word: M66>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.Line
Python Library Documentation: class Line in module pygcode.line
class Line(builtins.object)
| Line(text=None)
|
| Methods defined here:
|
| __init__(self, text=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| __str__(self)
| Return str(self).
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| gcodes
| self.block.gcodes passthrough
|
| text
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| line_regex = re.compile('^(?P<block_and_comment>.*?)?(?P<macro>%.*%?)?...
pygcode.Machine
Python Library Documentation: class Machine in module pygcode.machine
class Machine(builtins.object)
| Machine to process gcodes, enforce axis limits, keep track of time, etc
|
| Methods defined here:
|
| __copy__(self)
|
| __init__(self)
| Initialize self. See help(type(self)) for accurate signature.
|
| abs2work(self, abs_pos)
| # Position conversions (considering offsets)
|
| block_modal_gcodes(self, block)
| Block's GCode list in current machine mode
| :param block: Block instance
| :return: list of gcodes, block.gcodes + <modal gcode, if there is one>
|
| clean_block(self, block)
| Remove invalid modal parameters from given block
| :param block: Block instance to clean
|
| modal_gcode(self, modal_params)
| :param ignore_unassigned: if truthy, unassigned parameters will be ignored
|
| move_to(self, rapid=False, **coords)
| Move machine to given position
|
| process_block(self, block)
|
| process_gcodes(self, *gcode_list, **kwargs)
| Process gcodes
| :param gcode_list: list of GCode instances
| :param modal_params: list of Word instances to be applied to current movement mode
|
| process_str(self, block_str)
|
| set_mode(self, *gcode_list)
|
| work2abs(self, work_pos)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| pos
| Return current position in current coordinate system
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| MODE_CLASS = <class 'pygcode.machine.Mode'>
| Machine's mode
|
|
| STATE_CLASS = <class 'pygcode.machine.State'>
| State of a Machine
|
|
| axes = {'X', 'Y', 'Z'}
|
| ignore_invalid_modal = False
pygcode.Mode
Python Library Documentation: class Mode in module pygcode.machine
class Mode(builtins.object)
| Mode(set_default=True)
|
| Machine's mode
|
| Methods defined here:
|
| __copy__(self)
|
| __getattr__(self, key)
|
| __init__(self, set_default=True)
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| Return str(self).
|
| set_mode(self, *gcode_list)
| Set machine mode from given gcodes (will not be processed)
| :param gcode_list: list of GCode instances (given as individual parameters)
| :return: dict of form: {<modal group>: <new mode GCode>, ...}
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| gcodes
| List of modal gcodes
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_mode = '\n G0 (movement: rapid)\n G17 ...(...
pygcode.NullMachine
Python Library Documentation: class NullMachine in module pygcode.machine
class NullMachine(Machine)
| Method resolution order:
| NullMachine
| Machine
| builtins.object
|
| Data and other attributes defined here:
|
| MODE_CLASS = <class 'pygcode.machine.NullMode'>
| # Null Machine
| # A machine that presumes nothing
|
|
| STATE_CLASS = <class 'pygcode.machine.NullState'>
|
| ----------------------------------------------------------------------
| Methods inherited from Machine:
|
| __copy__(self)
|
| __init__(self)
| Initialize self. See help(type(self)) for accurate signature.
|
| abs2work(self, abs_pos)
| # Position conversions (considering offsets)
|
| block_modal_gcodes(self, block)
| Block's GCode list in current machine mode
| :param block: Block instance
| :return: list of gcodes, block.gcodes + <modal gcode, if there is one>
|
| clean_block(self, block)
| Remove invalid modal parameters from given block
| :param block: Block instance to clean
|
| modal_gcode(self, modal_params)
| :param ignore_unassigned: if truthy, unassigned parameters will be ignored
|
| move_to(self, rapid=False, **coords)
| Move machine to given position
|
| process_block(self, block)
|
| process_gcodes(self, *gcode_list, **kwargs)
| Process gcodes
| :param gcode_list: list of GCode instances
| :param modal_params: list of Word instances to be applied to current movement mode
|
| process_str(self, block_str)
|
| set_mode(self, *gcode_list)
|
| work2abs(self, work_pos)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Machine:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| pos
| Return current position in current coordinate system
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Machine:
|
| axes = {'X', 'Y', 'Z'}
|
| ignore_invalid_modal = False
pygcode.NullMode
Python Library Documentation: class NullMode in module pygcode.machine
class NullMode(Mode)
| NullMode(set_default=True)
|
| # Null Machine
| # A machine that presumes nothing
|
| Method resolution order:
| NullMode
| Mode
| builtins.object
|
| Data and other attributes defined here:
|
| default_mode = ''
|
| ----------------------------------------------------------------------
| Methods inherited from Mode:
|
| __copy__(self)
|
| __getattr__(self, key)
|
| __init__(self, set_default=True)
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| Return str(self).
|
| set_mode(self, *gcode_list)
| Set machine mode from given gcodes (will not be processed)
| :param gcode_list: list of GCode instances (given as individual parameters)
| :return: dict of form: {<modal group>: <new mode GCode>, ...}
|
| ----------------------------------------------------------------------
| Readonly properties inherited from Mode:
|
| gcodes
| List of modal gcodes
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Mode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
pygcode.NullState
Python Library Documentation: class NullState in module pygcode.machine class NullState(State) | NullState(axes=None) | | Method resolution order: | NullState | State | builtins.object | | Methods inherited from State: | | __copy__(self) | | __init__(self, axes=None) | Initialize self. See help(type(self)) for accurate signature. | | __repr__(self) | Return repr(self). | | ---------------------------------------------------------------------- | Readonly properties inherited from State: | | coord_sys | Current equivalent coordinate system, including all | | ---------------------------------------------------------------------- | Data descriptors inherited from State: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
pygcode.Position
Python Library Documentation: class Position in module pygcode.machine
class Position(builtins.object)
| Position(axes=None, **kwargs)
|
| Methods defined here:
|
| __add__(self, other)
| # Arithmetic
|
| __copy__(self)
|
| __div__(self, scalar)
|
| __eq__(self, other)
| Return self==value.
|
| __getattr__(self, key)
| # Attributes Get/Set
|
| __init__(self, axes=None, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __mul__(self, scalar)
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __sub__(self, other)
|
| __truediv__ = __div__(self, scalar)
|
| update(self, **coords)
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| max(a, b)
|
| min(a, b)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| values
|
| vector
|
| words
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| unit
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| POSSIBLE_AXES = {'A', 'B', 'C', 'U', 'V', 'W', ...}
|
| __hash__ = None
|
| default_axes = 'XYZABCUVW'
|
| default_unit = 1
pygcode.State
Python Library Documentation: class State in module pygcode.machine class State(builtins.object) | State(axes=None) | | State of a Machine | | Methods defined here: | | __copy__(self) | | __init__(self, axes=None) | Initialize self. See help(type(self)) for accurate signature. | | __repr__(self) | Return repr(self). | | ---------------------------------------------------------------------- | Readonly properties defined here: | | coord_sys | Current equivalent coordinate system, including all | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
pygcode.Word
Python Library Documentation: class Word in module pygcode.words class Word(builtins.object) | Word(*args) | | Methods defined here: | | __eq__(self, other) | Return self==value. | | __ge__(self, other) | Return self>=value. | | __gt__(self, other) | Return self>value. | | __hash__(self) | Return hash(self). | | __init__(self, *args) | Initialize self. See help(type(self)) for accurate signature. | | __le__(self, other) | Return self<=value. | | __lt__(self, other) | Return self<value. | | __ne__(self, other) | Return self!=value. | | __repr__(self) | Return repr(self). | | __str__(self) | Return str(self). | | ---------------------------------------------------------------------- | Readonly properties defined here: | | description | | value_str | Clean string representation, for consistent file output | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object | | value
pygcode.split_gcodes
Python Library Documentation: function split_gcodes in module pygcode.gcodes
split_gcodes(gcode_list, splitter_class, sort_list=True)
Splits a list of GCode instances into 3, the center list containing the splitter_class gcode
:param gcode_list: list of GCode instances to split
:param splitter_class: class of gcode identifying split from left to right
:return: list of: [[<gcodes before splitter>], [<splitter instance>], [<gcodes after splitter>]]
pygcode.split_line
Python Library Documentation: function split_line in module pygcode.comment
split_line(line_text)
Split functional block content from comments
:param line_text: line from gcode file
:return: tuple of (str(<functional block code>), CommentBase(<comment(s)>))
pygcode.str2word
Python Library Documentation: function str2word in module pygcode.words str2word(word_str)
pygcode.text2gcodes
Python Library Documentation: function text2gcodes in module pygcode.gcodes
text2gcodes(text)
Convert text to GCode instances (must be fully formed; no modal parameters)
:param text: line from a g-code file
:return: tuple([<GCode>, <GCode>, ...], list(<unused words>))
pygcode.text2words
Python Library Documentation: function text2words in module pygcode.words
text2words(block_text)
Iterate through block text yielding Word instances
:param block_text: text for given block with comments removed
pygcode.words2dict
Python Library Documentation: function words2dict in module pygcode.words
words2dict(word_list, limit_word_letters=None)
Represent a list of words as a dict
:param limit_word_letters: iterable containing a white-list of word letters (None allows all)
:return: dict of the form: {<letter>: <value>, ... }
pygcode.words2gcodes
Python Library Documentation: function words2gcodes in module pygcode.gcodes
words2gcodes(words)
Group words into g-codes (includes both G & M codes)
:param words: list of Word instances
:return: tuple([<GCode>, <GCode>, ...], list(<unused words>))
pygcode.block.Block
Python Library Documentation: class Block in module pygcode.block class Block(builtins.object) | Block(text=None, verify=True) | | GCode block (effectively any gcode file line that defines any <word><value>) | | Methods defined here: | | __bool__(self) | | __getattr__(self, k) | | __init__(self, text=None, verify=True) | Block Constructor | :param A-Z: gcode parameter values | :param comment: comment text | | __len__(self) | Block length = number of identified gcodes (+ 1 if any modal parameters are defined) | :return: block length | | __nonzero__ = __bool__(self) | | __str__(self) | Return str(self). | | ---------------------------------------------------------------------- | Readonly properties defined here: | | text | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
pygcode.block.WORD_MAP
Python Library Documentation: dict object
class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| Methods defined here:
|
| __contains__(self, key, /)
| True if the dictionary has the specified key, else False.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the dict keys.
|
| __ror__(self, value, /)
| Return value|self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| D.clear() -> None. Remove all items from D.
|
| copy(...)
| D.copy() -> a shallow copy of D
|
| get(self, key, default=None, /)
| Return the value for key if key is in the dictionary, else default.
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
|
| If the key is not found, return the default if given; otherwise,
| raise a KeyError.
|
| popitem(self, /)
| Remove and return a (key, value) pair as a 2-tuple.
|
| Pairs are returned in LIFO (last-in, first-out) order.
| Raises KeyError if the dict is empty.
|
| setdefault(self, key, default=None, /)
| Insert key with a value of default if key is not in the dictionary.
|
| Return the value for key if key is in the dictionary, else default.
|
| update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...)
| See PEP 585
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
pygcode.block.text2words
Python Library Documentation: function text2words in module pygcode.words
text2words(block_text)
Iterate through block text yielding Word instances
:param block_text: text for given block with comments removed
pygcode.block.words2gcodes
Python Library Documentation: function words2gcodes in module pygcode.gcodes
words2gcodes(words)
Group words into g-codes (includes both G & M codes)
:param words: list of Word instances
:return: tuple([<GCode>, <GCode>, ...], list(<unused words>))
pygcode.words.CLEAN_CODE
Python Library Documentation: function _clean_codestr in module pygcode.words
_clean_codestr(value)
# Value cleaning functions
pygcode.words.CLEAN_FLOAT
Python Library Documentation: function <lambda> in module pygcode.words <lambda> lambda v
pygcode.words.CLEAN_INT
Python Library Documentation: function <lambda> in module pygcode.words <lambda> lambda v
pygcode.words.CLEAN_NONE
Python Library Documentation: function <lambda> in module pygcode.words <lambda> lambda v
pygcode.words.GCodeBlockFormatError
Python Library Documentation: class GCodeBlockFormatError in module pygcode.exceptions class GCodeBlockFormatError(builtins.Exception) | Raised when errors encountered while parsing block text | | Method resolution order: | GCodeBlockFormatError | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Methods inherited from builtins.Exception: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Exception: | | __new__(*args, **kwargs) class method of builtins.Exception | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pygcode.words.GCodeWordStrError
Python Library Documentation: class GCodeWordStrError in module pygcode.exceptions class GCodeWordStrError(builtins.Exception) | Raised when issues found while parsing a word string | | Method resolution order: | GCodeWordStrError | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Methods inherited from builtins.Exception: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Exception: | | __new__(*args, **kwargs) class method of builtins.Exception | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pygcode.words.REGEX_CODE
Python Library Documentation: Pattern in module re object class Pattern(builtins.object) | Compiled regular expression object. | | Methods defined here: | | __copy__(self, /) | | __deepcopy__(self, memo, /) | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | findall(self, /, string, pos=0, endpos=9223372036854775807) | Return a list of all non-overlapping matches of pattern in string. | | finditer(self, /, string, pos=0, endpos=9223372036854775807) | Return an iterator over all non-overlapping matches for the RE pattern in string. | | For each match, the iterator returns a match object. | | fullmatch(self, /, string, pos=0, endpos=9223372036854775807) | Matches against all of the string. | | match(self, /, string, pos=0, endpos=9223372036854775807) | Matches zero or more characters at the beginning of the string. | | scanner(self, /, string, pos=0, endpos=9223372036854775807) | | search(self, /, string, pos=0, endpos=9223372036854775807) | Scan through string looking for a match, and return a corresponding match object instance. | | Return None if no position in the string matches. | | split(self, /, string, maxsplit=0) | Split string by the occurrences of pattern. | | sub(self, /, repl, string, count=0) | Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. | | subn(self, /, repl, string, count=0) | Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl. | | ---------------------------------------------------------------------- | Class methods defined here: | | __class_getitem__(...) | See PEP 585 | | ---------------------------------------------------------------------- | Data descriptors defined here: | | flags | The regex matching flags. | | groupindex | A dictionary mapping group names to group numbers. | | groups | The number of capturing groups in the pattern. | | pattern | The pattern string from which the RE object was compiled.
pygcode.words.REGEX_FLOAT
Python Library Documentation: Pattern in module re object class Pattern(builtins.object) | Compiled regular expression object. | | Methods defined here: | | __copy__(self, /) | | __deepcopy__(self, memo, /) | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | findall(self, /, string, pos=0, endpos=9223372036854775807) | Return a list of all non-overlapping matches of pattern in string. | | finditer(self, /, string, pos=0, endpos=9223372036854775807) | Return an iterator over all non-overlapping matches for the RE pattern in string. | | For each match, the iterator returns a match object. | | fullmatch(self, /, string, pos=0, endpos=9223372036854775807) | Matches against all of the string. | | match(self, /, string, pos=0, endpos=9223372036854775807) | Matches zero or more characters at the beginning of the string. | | scanner(self, /, string, pos=0, endpos=9223372036854775807) | | search(self, /, string, pos=0, endpos=9223372036854775807) | Scan through string looking for a match, and return a corresponding match object instance. | | Return None if no position in the string matches. | | split(self, /, string, maxsplit=0) | Split string by the occurrences of pattern. | | sub(self, /, repl, string, count=0) | Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. | | subn(self, /, repl, string, count=0) | Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl. | | ---------------------------------------------------------------------- | Class methods defined here: | | __class_getitem__(...) | See PEP 585 | | ---------------------------------------------------------------------- | Data descriptors defined here: | | flags | The regex matching flags. | | groupindex | A dictionary mapping group names to group numbers. | | groups | The number of capturing groups in the pattern. | | pattern | The pattern string from which the RE object was compiled.
pygcode.words.REGEX_INT
Python Library Documentation: Pattern in module re object class Pattern(builtins.object) | Compiled regular expression object. | | Methods defined here: | | __copy__(self, /) | | __deepcopy__(self, memo, /) | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | findall(self, /, string, pos=0, endpos=9223372036854775807) | Return a list of all non-overlapping matches of pattern in string. | | finditer(self, /, string, pos=0, endpos=9223372036854775807) | Return an iterator over all non-overlapping matches for the RE pattern in string. | | For each match, the iterator returns a match object. | | fullmatch(self, /, string, pos=0, endpos=9223372036854775807) | Matches against all of the string. | | match(self, /, string, pos=0, endpos=9223372036854775807) | Matches zero or more characters at the beginning of the string. | | scanner(self, /, string, pos=0, endpos=9223372036854775807) | | search(self, /, string, pos=0, endpos=9223372036854775807) | Scan through string looking for a match, and return a corresponding match object instance. | | Return None if no position in the string matches. | | split(self, /, string, maxsplit=0) | Split string by the occurrences of pattern. | | sub(self, /, repl, string, count=0) | Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. | | subn(self, /, repl, string, count=0) | Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl. | | ---------------------------------------------------------------------- | Class methods defined here: | | __class_getitem__(...) | See PEP 585 | | ---------------------------------------------------------------------- | Data descriptors defined here: | | flags | The regex matching flags. | | groupindex | A dictionary mapping group names to group numbers. | | groups | The number of capturing groups in the pattern. | | pattern | The pattern string from which the RE object was compiled.
pygcode.words.REGEX_POSITIVEINT
Python Library Documentation: Pattern in module re object class Pattern(builtins.object) | Compiled regular expression object. | | Methods defined here: | | __copy__(self, /) | | __deepcopy__(self, memo, /) | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | findall(self, /, string, pos=0, endpos=9223372036854775807) | Return a list of all non-overlapping matches of pattern in string. | | finditer(self, /, string, pos=0, endpos=9223372036854775807) | Return an iterator over all non-overlapping matches for the RE pattern in string. | | For each match, the iterator returns a match object. | | fullmatch(self, /, string, pos=0, endpos=9223372036854775807) | Matches against all of the string. | | match(self, /, string, pos=0, endpos=9223372036854775807) | Matches zero or more characters at the beginning of the string. | | scanner(self, /, string, pos=0, endpos=9223372036854775807) | | search(self, /, string, pos=0, endpos=9223372036854775807) | Scan through string looking for a match, and return a corresponding match object instance. | | Return None if no position in the string matches. | | split(self, /, string, maxsplit=0) | Split string by the occurrences of pattern. | | sub(self, /, repl, string, count=0) | Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. | | subn(self, /, repl, string, count=0) | Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl. | | ---------------------------------------------------------------------- | Class methods defined here: | | __class_getitem__(...) | See PEP 585 | | ---------------------------------------------------------------------- | Data descriptors defined here: | | flags | The regex matching flags. | | groupindex | A dictionary mapping group names to group numbers. | | groups | The number of capturing groups in the pattern. | | pattern | The pattern string from which the RE object was compiled.
pygcode.words.WORD_MAP
Python Library Documentation: dict object
class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| Methods defined here:
|
| __contains__(self, key, /)
| True if the dictionary has the specified key, else False.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the dict keys.
|
| __ror__(self, value, /)
| Return value|self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| D.clear() -> None. Remove all items from D.
|
| copy(...)
| D.copy() -> a shallow copy of D
|
| get(self, key, default=None, /)
| Return the value for key if key is in the dictionary, else default.
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
|
| If the key is not found, return the default if given; otherwise,
| raise a KeyError.
|
| popitem(self, /)
| Remove and return a (key, value) pair as a 2-tuple.
|
| Pairs are returned in LIFO (last-in, first-out) order.
| Raises KeyError if the dict is empty.
|
| setdefault(self, key, default=None, /)
| Insert key with a value of default if key is not in the dictionary.
|
| Return the value for key if key is in the dictionary, else default.
|
| update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...)
| See PEP 585
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
pygcode.words.Word
Python Library Documentation: class Word in module pygcode.words class Word(builtins.object) | Word(*args) | | Methods defined here: | | __eq__(self, other) | Return self==value. | | __ge__(self, other) | Return self>=value. | | __gt__(self, other) | Return self>value. | | __hash__(self) | Return hash(self). | | __init__(self, *args) | Initialize self. See help(type(self)) for accurate signature. | | __le__(self, other) | Return self<=value. | | __lt__(self, other) | Return self<value. | | __ne__(self, other) | Return self!=value. | | __repr__(self) | Return repr(self). | | __str__(self) | Return str(self). | | ---------------------------------------------------------------------- | Readonly properties defined here: | | description | | value_str | Clean string representation, for consistent file output | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object | | value
pygcode.words.str2word
Python Library Documentation: function str2word in module pygcode.words str2word(word_str)
pygcode.words.text2words
Python Library Documentation: function text2words in module pygcode.words
text2words(block_text)
Iterate through block text yielding Word instances
:param block_text: text for given block with comments removed
pygcode.words.words2dict
Python Library Documentation: function words2dict in module pygcode.words
words2dict(word_list, limit_word_letters=None)
Represent a list of words as a dict
:param limit_word_letters: iterable containing a white-list of word letters (None allows all)
:return: dict of the form: {<letter>: <value>, ... }
pygcode.gcodes.GCode
Python Library Documentation: class GCode in module pygcode.gcodes
class GCode(builtins.object)
| GCode(*words, **params)
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
|
| default_word = None
|
| exec_order = 999
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeAbsoluteArcDistanceMode
Python Library Documentation: class GCodeAbsoluteArcDistanceMode in module pygcode.gcodes
class GCodeAbsoluteArcDistanceMode(GCodeDistanceMode)
| GCodeAbsoluteArcDistanceMode(*words, **params)
|
| G90.1: Absolute Distance Mode for Arc IJK Parameters
|
| Method resolution order:
| GCodeAbsoluteArcDistanceMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 4
|
| word_key = <Word: G90.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeAbsoluteDistanceMode
Python Library Documentation: class GCodeAbsoluteDistanceMode in module pygcode.gcodes
class GCodeAbsoluteDistanceMode(GCodeDistanceMode)
| GCodeAbsoluteDistanceMode(*words, **params)
|
| G90: Absolute Distance Mode
|
| Method resolution order:
| GCodeAbsoluteDistanceMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 3
|
| word_key = <Word: G90>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeAdaptiveFeed
Python Library Documentation: class GCodeAdaptiveFeed in module pygcode.gcodes
class GCodeAdaptiveFeed(GCodeOtherModal)
| GCodeAdaptiveFeed(*words, **params)
|
| M52: Adaptive Feed Control
|
| Method resolution order:
| GCodeAdaptiveFeed
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| param_letters = {'P'}
|
| word_key = <Word: M52>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeAddToolLengthOffset
Python Library Documentation: class GCodeAddToolLengthOffset in module pygcode.gcodes
class GCodeAddToolLengthOffset(GCodeToolLength)
| GCodeAddToolLengthOffset(*words, **params)
|
| G43.2: Appkly Additional Tool Length Offset
|
| Method resolution order:
| GCodeAddToolLengthOffset
| GCodeToolLength
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'H'}
|
| word_key = <Word: G43.2>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeToolLength:
|
| exec_order = 180
|
| modal_group = 8
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeAnalogOutput
Python Library Documentation: class GCodeAnalogOutput in module pygcode.gcodes
class GCodeAnalogOutput(GCodeIO)
| GCodeAnalogOutput(*words, **params)
|
| Analog Output
|
| Method resolution order:
| GCodeAnalogOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'T'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeAnalogOutputImmediate
Python Library Documentation: class GCodeAnalogOutputImmediate in module pygcode.gcodes
class GCodeAnalogOutputImmediate(GCodeAnalogOutput)
| GCodeAnalogOutputImmediate(*words, **params)
|
| M68: Analog Output, Immediate
|
| Method resolution order:
| GCodeAnalogOutputImmediate
| GCodeAnalogOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M68>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeAnalogOutput:
|
| param_letters = {'T'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeAnalogOutputSyncd
Python Library Documentation: class GCodeAnalogOutputSyncd in module pygcode.gcodes
class GCodeAnalogOutputSyncd(GCodeAnalogOutput)
| GCodeAnalogOutputSyncd(*words, **params)
|
| M67: Analog Output, Synchronized
|
| Method resolution order:
| GCodeAnalogOutputSyncd
| GCodeAnalogOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M67>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeAnalogOutput:
|
| param_letters = {'T'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeArcMove
Python Library Documentation: class GCodeArcMove in module pygcode.gcodes
class GCodeArcMove(GCodeMotion)
| GCodeArcMove(*words, **params)
|
| Arc Move
|
| Method resolution order:
| GCodeArcMove
| GCodeMotion
| GCode
| builtins.object
|
| Methods defined here:
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'I', 'J', 'K', ...}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeArcMoveCCW
Python Library Documentation: class GCodeArcMoveCCW in module pygcode.gcodes
class GCodeArcMoveCCW(GCodeArcMove)
| GCodeArcMoveCCW(*words, **params)
|
| G3: Arc Move (counter-clockwise)
|
| Method resolution order:
| GCodeArcMoveCCW
| GCodeArcMove
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G03>
|
| ----------------------------------------------------------------------
| Methods inherited from GCodeArcMove:
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeArcMove:
|
| param_letters = {'A', 'B', 'C', 'I', 'J', 'K', ...}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeArcMoveCW
Python Library Documentation: class GCodeArcMoveCW in module pygcode.gcodes
class GCodeArcMoveCW(GCodeArcMove)
| GCodeArcMoveCW(*words, **params)
|
| G2: Arc Move (clockwise)
|
| Method resolution order:
| GCodeArcMoveCW
| GCodeArcMove
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G02>
|
| ----------------------------------------------------------------------
| Methods inherited from GCodeArcMove:
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeArcMove:
|
| param_letters = {'A', 'B', 'C', 'I', 'J', 'K', ...}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeBoringCycleDwellFeedOut
Python Library Documentation: class GCodeBoringCycleDwellFeedOut in module pygcode.gcodes
class GCodeBoringCycleDwellFeedOut(GCodeCannedCycle)
| GCodeBoringCycleDwellFeedOut(*words, **params)
|
| G89: Boring Cycle, Dwell, Feed Out
|
| Method resolution order:
| GCodeBoringCycleDwellFeedOut
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'P', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'P', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G89>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeBoringCycleFeedOut
Python Library Documentation: class GCodeBoringCycleFeedOut in module pygcode.gcodes
class GCodeBoringCycleFeedOut(GCodeCannedCycle)
| GCodeBoringCycleFeedOut(*words, **params)
|
| G85: Boring Cycle, Feed Out
|
| Method resolution order:
| GCodeBoringCycleFeedOut
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'P', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'P', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G85>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCancelCannedCycle
Python Library Documentation: class GCodeCancelCannedCycle in module pygcode.gcodes
class GCodeCancelCannedCycle(GCodeMotion)
| GCodeCancelCannedCycle(*words, **params)
|
| G80: Cancel Canned Cycle
|
| Method resolution order:
| GCodeCancelCannedCycle
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 241
|
| modal_group = None
|
| word_key = <Word: G80>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| param_letters = {'A', 'B', 'C', 'U', 'V', 'W', ...}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCancelToolLengthOffset
Python Library Documentation: class GCodeCancelToolLengthOffset in module pygcode.gcodes
class GCodeCancelToolLengthOffset(GCodeToolLength)
| GCodeCancelToolLengthOffset(*words, **params)
|
| G49: Cancel Tool Length Compensation
|
| Method resolution order:
| GCodeCancelToolLengthOffset
| GCodeToolLength
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G49>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeToolLength:
|
| exec_order = 180
|
| modal_group = 8
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCannedCycle
Python Library Documentation: class GCodeCannedCycle in module pygcode.gcodes
class GCodeCannedCycle(GCode)
| GCodeCannedCycle(*words, **params)
|
| Method resolution order:
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 242
|
| modal_group = 1
|
| param_letters = {'U', 'V', 'W', 'X', 'Y', 'Z'}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCannedCycleReturnPrevLevel
Python Library Documentation: class GCodeCannedCycleReturnPrevLevel in module pygcode.gcodes
class GCodeCannedCycleReturnPrevLevel(GCodeCannedReturnMode)
| GCodeCannedCycleReturnPrevLevel(*words, **params)
|
| G98: Canned Cycle Return to the level set prior to cycle start
|
| Method resolution order:
| GCodeCannedCycleReturnPrevLevel
| GCodeCannedReturnMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G98>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedReturnMode:
|
| exec_order = 220
|
| modal_group = 10
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCannedCycleReturnToR
Python Library Documentation: class GCodeCannedCycleReturnToR in module pygcode.gcodes
class GCodeCannedCycleReturnToR(GCodeCannedReturnMode)
| GCodeCannedCycleReturnToR(*words, **params)
|
| G99: Canned Cycle Return to the level set by R
|
| Method resolution order:
| GCodeCannedCycleReturnToR
| GCodeCannedReturnMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G99>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedReturnMode:
|
| exec_order = 220
|
| modal_group = 10
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCannedReturnMode
Python Library Documentation: class GCodeCannedReturnMode in module pygcode.gcodes
class GCodeCannedReturnMode(GCode)
| GCodeCannedReturnMode(*words, **params)
|
| Method resolution order:
| GCodeCannedReturnMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 220
|
| modal_group = 10
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCoolant
Python Library Documentation: class GCodeCoolant in module pygcode.gcodes
class GCodeCoolant(GCode)
| GCodeCoolant(*words, **params)
|
| Method resolution order:
| GCodeCoolant
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 110
|
| modal_group = 108
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCoolantFloodOn
Python Library Documentation: class GCodeCoolantFloodOn in module pygcode.gcodes
class GCodeCoolantFloodOn(GCodeCoolant)
| GCodeCoolantFloodOn(*words, **params)
|
| M8: turn flood coolant on
|
| Method resolution order:
| GCodeCoolantFloodOn
| GCodeCoolant
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M08>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCoolant:
|
| exec_order = 110
|
| modal_group = 108
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCoolantMistOn
Python Library Documentation: class GCodeCoolantMistOn in module pygcode.gcodes
class GCodeCoolantMistOn(GCodeCoolant)
| GCodeCoolantMistOn(*words, **params)
|
| M7: turn mist coolant on
|
| Method resolution order:
| GCodeCoolantMistOn
| GCodeCoolant
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M07>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCoolant:
|
| exec_order = 110
|
| modal_group = 108
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCoolantOff
Python Library Documentation: class GCodeCoolantOff in module pygcode.gcodes
class GCodeCoolantOff(GCodeCoolant)
| GCodeCoolantOff(*words, **params)
|
| M9: turn all coolant off
|
| Method resolution order:
| GCodeCoolantOff
| GCodeCoolant
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M09>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCoolant:
|
| exec_order = 110
|
| modal_group = 108
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCoordSystemOffset
Python Library Documentation: class GCodeCoordSystemOffset in module pygcode.gcodes
class GCodeCoordSystemOffset(GCodeNonModal)
| GCodeCoordSystemOffset(*words, **params)
|
| G92: Coordinate System Offset
|
| Method resolution order:
| GCodeCoordSystemOffset
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 230
|
| word_key = <Word: G92>
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCublcSpline
Python Library Documentation: class GCodeCublcSpline in module pygcode.gcodes
class GCodeCublcSpline(GCodeMotion)
| GCodeCublcSpline(*words, **params)
|
| G5: Cubic Spline
|
| Method resolution order:
| GCodeCublcSpline
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'I', 'J', 'P', ...}
|
| word_key = <Word: G05>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCutterCompLeft
Python Library Documentation: class GCodeCutterCompLeft in module pygcode.gcodes
class GCodeCutterCompLeft(GCodeCutterRadiusComp)
| GCodeCutterCompLeft(*words, **params)
|
| G41: Cutter Radius Compensation (left)
|
| Method resolution order:
| GCodeCutterCompLeft
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D'}
|
| word_key = <Word: G41>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCutterRadiusComp:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCutterCompRight
Python Library Documentation: class GCodeCutterCompRight in module pygcode.gcodes
class GCodeCutterCompRight(GCodeCutterRadiusComp)
| GCodeCutterCompRight(*words, **params)
|
| G42: Cutter Radius Compensation (right)
|
| Method resolution order:
| GCodeCutterCompRight
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D'}
|
| word_key = <Word: G42>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCutterRadiusComp:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCutterRadiusComp
Python Library Documentation: class GCodeCutterRadiusComp in module pygcode.gcodes
class GCodeCutterRadiusComp(GCode)
| GCodeCutterRadiusComp(*words, **params)
|
| Method resolution order:
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeCutterRadiusCompOff
Python Library Documentation: class GCodeCutterRadiusCompOff in module pygcode.gcodes
class GCodeCutterRadiusCompOff(GCodeCutterRadiusComp)
| GCodeCutterRadiusCompOff(*words, **params)
|
| G40: Cutter Radius Compensation Off
|
| Method resolution order:
| GCodeCutterRadiusCompOff
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G40>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCutterRadiusComp:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDefinition
Python Library Documentation: class GCodeDefinition in module pygcode.gcodes
class GCodeDefinition(GCode)
| GCodeDefinition(*words, **params)
|
| Method resolution order:
| GCodeDefinition
| GCode
| builtins.object
|
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| exec_order = 999
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDigitalOutput
Python Library Documentation: class GCodeDigitalOutput in module pygcode.gcodes
class GCodeDigitalOutput(GCodeIO)
| GCodeDigitalOutput(*words, **params)
|
| Digital Output Control
|
| Method resolution order:
| GCodeDigitalOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'P'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDigitalOutputOff
Python Library Documentation: class GCodeDigitalOutputOff in module pygcode.gcodes
class GCodeDigitalOutputOff(GCodeDigitalOutput)
| GCodeDigitalOutputOff(*words, **params)
|
| M65: turn off digital output immediately
|
| Method resolution order:
| GCodeDigitalOutputOff
| GCodeDigitalOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M65>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDigitalOutput:
|
| param_letters = {'P'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDigitalOutputOffSyncd
Python Library Documentation: class GCodeDigitalOutputOffSyncd in module pygcode.gcodes
class GCodeDigitalOutputOffSyncd(GCodeDigitalOutput)
| GCodeDigitalOutputOffSyncd(*words, **params)
|
| M63: turn off digital output synchronized with motion
|
| Method resolution order:
| GCodeDigitalOutputOffSyncd
| GCodeDigitalOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M63>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDigitalOutput:
|
| param_letters = {'P'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDigitalOutputOn
Python Library Documentation: class GCodeDigitalOutputOn in module pygcode.gcodes
class GCodeDigitalOutputOn(GCodeDigitalOutput)
| GCodeDigitalOutputOn(*words, **params)
|
| M64: turn on digital output immediately
|
| Method resolution order:
| GCodeDigitalOutputOn
| GCodeDigitalOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M64>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDigitalOutput:
|
| param_letters = {'P'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDigitalOutputOnSyncd
Python Library Documentation: class GCodeDigitalOutputOnSyncd in module pygcode.gcodes
class GCodeDigitalOutputOnSyncd(GCodeDigitalOutput)
| GCodeDigitalOutputOnSyncd(*words, **params)
|
| M62: turn on digital output synchronized with motion
|
| Method resolution order:
| GCodeDigitalOutputOnSyncd
| GCodeDigitalOutput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M62>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDigitalOutput:
|
| param_letters = {'P'}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDistanceMode
Python Library Documentation: class GCodeDistanceMode in module pygcode.gcodes
class GCodeDistanceMode(GCode)
| GCodeDistanceMode(*words, **params)
|
| Method resolution order:
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDrillingCycle
Python Library Documentation: class GCodeDrillingCycle in module pygcode.gcodes
class GCodeDrillingCycle(GCodeCannedCycle)
| GCodeDrillingCycle(*words, **params)
|
| G81: Drilling Cycle
|
| Method resolution order:
| GCodeDrillingCycle
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'P', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'P', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G81>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDrillingCycleChipBreaking
Python Library Documentation: class GCodeDrillingCycleChipBreaking in module pygcode.gcodes
class GCodeDrillingCycleChipBreaking(GCodeCannedCycle)
| GCodeDrillingCycleChipBreaking(*words, **params)
|
| G73: Drilling Cycle, ChipBreaking
|
| Method resolution order:
| GCodeDrillingCycleChipBreaking
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'Q', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'Q', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G73>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDrillingCycleDwell
Python Library Documentation: class GCodeDrillingCycleDwell in module pygcode.gcodes
class GCodeDrillingCycleDwell(GCodeCannedCycle)
| GCodeDrillingCycleDwell(*words, **params)
|
| G82: Drilling Cycle, Dwell
|
| Method resolution order:
| GCodeDrillingCycleDwell
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'P', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'P', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G82>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDrillingCyclePeck
Python Library Documentation: class GCodeDrillingCyclePeck in module pygcode.gcodes
class GCodeDrillingCyclePeck(GCodeCannedCycle)
| GCodeDrillingCyclePeck(*words, **params)
|
| G83: Drilling Cycle, Peck
|
| Method resolution order:
| GCodeDrillingCyclePeck
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_param_letters = {'Q', 'R', 'U', 'V', 'W', 'X', ...}
|
| param_letters = {'L', 'Q', 'R', 'U', 'V', 'W', ...}
|
| word_key = <Word: G83>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDwell
Python Library Documentation: class GCodeDwell in module pygcode.gcodes
class GCodeDwell(GCodeMotion)
| GCodeDwell(*words, **params)
|
| G4: Dwell
|
| Method resolution order:
| GCodeDwell
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 140
|
| modal_group = None
|
| param_letters = {'P'}
|
| word_key = <Word: G04>
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDynamicCutterCompLeft
Python Library Documentation: class GCodeDynamicCutterCompLeft in module pygcode.gcodes
class GCodeDynamicCutterCompLeft(GCodeCutterRadiusComp)
| GCodeDynamicCutterCompLeft(*words, **params)
|
| G41.1: Dynamic Cutter Radius Compensation (left)
|
| Method resolution order:
| GCodeDynamicCutterCompLeft
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D', 'L'}
|
| word_key = <Word: G41.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCutterRadiusComp:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDynamicCutterCompRight
Python Library Documentation: class GCodeDynamicCutterCompRight in module pygcode.gcodes
class GCodeDynamicCutterCompRight(GCodeCutterRadiusComp)
| GCodeDynamicCutterCompRight(*words, **params)
|
| G42.1: Dynamic Cutter Radius Compensation (right)
|
| Method resolution order:
| GCodeDynamicCutterCompRight
| GCodeCutterRadiusComp
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D', 'L'}
|
| word_key = <Word: G42.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCutterRadiusComp:
|
| exec_order = 170
|
| modal_group = 7
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeDynamicToolLengthOffset
Python Library Documentation: class GCodeDynamicToolLengthOffset in module pygcode.gcodes
class GCodeDynamicToolLengthOffset(GCodeToolLength)
| GCodeDynamicToolLengthOffset(*words, **params)
|
| G43.1: Dynamic Tool Length Offset
|
| Method resolution order:
| GCodeDynamicToolLengthOffset
| GCodeToolLength
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G43.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeToolLength:
|
| exec_order = 180
|
| modal_group = 8
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeEndProgram
Python Library Documentation: class GCodeEndProgram in module pygcode.gcodes
class GCodeEndProgram(GCodeProgramControl)
| GCodeEndProgram(*words, **params)
|
| M2: Program End
|
| Method resolution order:
| GCodeEndProgram
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M02>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeProgramControl:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeEndProgramPalletShuttle
Python Library Documentation: class GCodeEndProgramPalletShuttle in module pygcode.gcodes
class GCodeEndProgramPalletShuttle(GCodeProgramControl)
| GCodeEndProgramPalletShuttle(*words, **params)
|
| M30: exchange pallet shuttles and end the program
|
| Method resolution order:
| GCodeEndProgramPalletShuttle
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M30>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeProgramControl:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeExactPathMode
Python Library Documentation: class GCodeExactPathMode in module pygcode.gcodes
class GCodeExactPathMode(GCodePathControlMode)
| GCodeExactPathMode(*words, **params)
|
| G61: Exact path mode
|
| Method resolution order:
| GCodeExactPathMode
| GCodePathControlMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G61>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePathControlMode:
|
| exec_order = 200
|
| modal_group = 13
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeExactStopMode
Python Library Documentation: class GCodeExactStopMode in module pygcode.gcodes
class GCodeExactStopMode(GCodePathControlMode)
| GCodeExactStopMode(*words, **params)
|
| G61.1: Exact stop mode
|
| Method resolution order:
| GCodeExactStopMode
| GCodePathControlMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G61.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePathControlMode:
|
| exec_order = 200
|
| modal_group = 13
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeFeedOverride
Python Library Documentation: class GCodeFeedOverride in module pygcode.gcodes
class GCodeFeedOverride(GCodeOtherModal)
| GCodeFeedOverride(*words, **params)
|
| M50: Feed Override Control
|
| Method resolution order:
| GCodeFeedOverride
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| param_letters = {'P'}
|
| word_key = <Word: M50>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeFeedRate
Python Library Documentation: class GCodeFeedRate in module pygcode.gcodes
class GCodeFeedRate(GCodeOtherModal)
| GCodeFeedRate(*words, **params)
|
| F: Set Feed Rate
|
| Method resolution order:
| GCodeFeedRate
| GCodeOtherModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: F0>
|
| exec_order = 40
|
| modal_group = 201
|
| word_letter = 'F'
|
| word_value_configurable = True
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
pygcode.gcodes.GCodeFeedRateMode
Python Library Documentation: class GCodeFeedRateMode in module pygcode.gcodes
class GCodeFeedRateMode(GCode)
| GCodeFeedRateMode(*words, **params)
|
| Method resolution order:
| GCodeFeedRateMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 30
|
| modal_group = 5
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeFeedStop
Python Library Documentation: class GCodeFeedStop in module pygcode.gcodes
class GCodeFeedStop(GCodeOtherModal)
| GCodeFeedStop(*words, **params)
|
| M53: Feed Stop Control
|
| Method resolution order:
| GCodeFeedStop
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| param_letters = {'P'}
|
| word_key = <Word: M53>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeGotoPredefinedPosition
Python Library Documentation: class GCodeGotoPredefinedPosition in module pygcode.gcodes
class GCodeGotoPredefinedPosition(GCodeNonModal)
| GCodeGotoPredefinedPosition(*words, **params)
|
| G28,G30: Goto Predefined Position (rapid movement)
|
| Method resolution order:
| GCodeGotoPredefinedPosition
| GCodeNonModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: G28>
|
| exec_order = 230
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_value_configurable = False
pygcode.gcodes.GCodeIO
Python Library Documentation: class GCodeIO in module pygcode.gcodes
class GCodeIO(GCode)
| GCodeIO(*words, **params)
|
| Method resolution order:
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeIncrementalArcDistanceMode
Python Library Documentation: class GCodeIncrementalArcDistanceMode in module pygcode.gcodes
class GCodeIncrementalArcDistanceMode(GCodeDistanceMode)
| GCodeIncrementalArcDistanceMode(*words, **params)
|
| G91.1: Incremental Distance Mode for Arc IJK Parameters
|
| Method resolution order:
| GCodeIncrementalArcDistanceMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 4
|
| word_key = <Word: G91.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeIncrementalDistanceMode
Python Library Documentation: class GCodeIncrementalDistanceMode in module pygcode.gcodes
class GCodeIncrementalDistanceMode(GCodeDistanceMode)
| GCodeIncrementalDistanceMode(*words, **params)
|
| G91: Incremental Distance Mode
|
| Method resolution order:
| GCodeIncrementalDistanceMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 3
|
| word_key = <Word: G91>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeInverseTimeMode
Python Library Documentation: class GCodeInverseTimeMode in module pygcode.gcodes
class GCodeInverseTimeMode(GCodeFeedRateMode)
| GCodeInverseTimeMode(*words, **params)
|
| G93: Inverse Time Mode
|
| Method resolution order:
| GCodeInverseTimeMode
| GCodeFeedRateMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G93>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeFeedRateMode:
|
| exec_order = 30
|
| modal_group = 5
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeLatheDiameterMode
Python Library Documentation: class GCodeLatheDiameterMode in module pygcode.gcodes
class GCodeLatheDiameterMode(GCodeDistanceMode)
| GCodeLatheDiameterMode(*words, **params)
|
| G7: Lathe Diameter Mode
|
| Method resolution order:
| GCodeLatheDiameterMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 15
|
| word_key = <Word: G07>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeLatheRadiusMode
Python Library Documentation: class GCodeLatheRadiusMode in module pygcode.gcodes
class GCodeLatheRadiusMode(GCodeDistanceMode)
| GCodeLatheRadiusMode(*words, **params)
|
| G8: Lathe Radius Mode
|
| Method resolution order:
| GCodeLatheRadiusMode
| GCodeDistanceMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 15
|
| word_key = <Word: G08>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeDistanceMode:
|
| exec_order = 210
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeLineNumber
Python Library Documentation: class GCodeLineNumber in module pygcode.gcodes
class GCodeLineNumber(GCodeDefinition)
| GCodeLineNumber(*words, **params)
|
| N: Line Number
|
| Method resolution order:
| GCodeLineNumber
| GCodeDefinition
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| number
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| exec_order = 0
|
| word_letter = 'N'
|
| word_value_configurable = True
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
pygcode.gcodes.GCodeLinearMove
Python Library Documentation: class GCodeLinearMove in module pygcode.gcodes
class GCodeLinearMove(GCodeMotion)
| GCodeLinearMove(*words, **params)
|
| G1: Linear Move
|
| Method resolution order:
| GCodeLinearMove
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G01>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| param_letters = {'A', 'B', 'C', 'U', 'V', 'W', ...}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeMotion
Python Library Documentation: class GCodeMotion in module pygcode.gcodes
class GCodeMotion(GCode)
| GCodeMotion(*words, **params)
|
| Method resolution order:
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 242
|
| modal_group = 1
|
| param_letters = {'A', 'B', 'C', 'U', 'V', 'W', ...}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeMoveInMachineCoords
Python Library Documentation: class GCodeMoveInMachineCoords in module pygcode.gcodes
class GCodeMoveInMachineCoords(GCodeNonModal)
| GCodeMoveInMachineCoords(*words, **params)
|
| G53: Move in Machine Coordinates
|
| Method resolution order:
| GCodeMoveInMachineCoords
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 240
|
| word_key = <Word: G53>
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeNURBS
Python Library Documentation: class GCodeNURBS in module pygcode.gcodes
class GCodeNURBS(GCodeMotion)
| GCodeNURBS(*words, **params)
|
| G5.2: Non-uniform rational basis spline (NURBS)
|
| Method resolution order:
| GCodeNURBS
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'L', 'P', 'U', ...}
|
| word_key = <Word: G05.2>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeNURBSEnd
Python Library Documentation: class GCodeNURBSEnd in module pygcode.gcodes
class GCodeNURBSEnd(GCodeNURBS)
| GCodeNURBSEnd(*words, **params)
|
| G5.3: end NURBS mode
|
| Method resolution order:
| GCodeNURBSEnd
| GCodeNURBS
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G05.3>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeNURBS:
|
| param_letters = {'A', 'B', 'C', 'L', 'P', 'U', ...}
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeNonModal
Python Library Documentation: class GCodeNonModal in module pygcode.gcodes
class GCodeNonModal(GCode)
| GCodeNonModal(*words, **params)
|
| Method resolution order:
| GCodeNonModal
| GCode
| builtins.object
|
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| exec_order = 999
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeOrientSpindle
Python Library Documentation: class GCodeOrientSpindle in module pygcode.gcodes
class GCodeOrientSpindle(GCodeSpindle)
| GCodeOrientSpindle(*words, **params)
|
| M19: Orient Spindle
|
| Method resolution order:
| GCodeOrientSpindle
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M19>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeOtherModal
Python Library Documentation: class GCodeOtherModal in module pygcode.gcodes
class GCodeOtherModal(GCode)
| GCodeOtherModal(*words, **params)
|
| Method resolution order:
| GCodeOtherModal
| GCode
| builtins.object
|
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| exec_order = 999
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodePalletChangePause
Python Library Documentation: class GCodePalletChangePause in module pygcode.gcodes
class GCodePalletChangePause(GCodeProgramControl)
| GCodePalletChangePause(*words, **params)
|
| M60: Pallet Change Pause
|
| Method resolution order:
| GCodePalletChangePause
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M60>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeProgramControl:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeParameterError
Python Library Documentation: class GCodeParameterError in module pygcode.exceptions class GCodeParameterError(builtins.Exception) | Raised for conflicting / invalid / badly formed parameters | | Method resolution order: | GCodeParameterError | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Methods inherited from builtins.Exception: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Exception: | | __new__(*args, **kwargs) class method of builtins.Exception | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pygcode.gcodes.GCodePathBlendingMode
Python Library Documentation: class GCodePathBlendingMode in module pygcode.gcodes
class GCodePathBlendingMode(GCodePathControlMode)
| GCodePathBlendingMode(*words, **params)
|
| G64: Path Blending
|
| Method resolution order:
| GCodePathBlendingMode
| GCodePathControlMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'P', 'Q'}
|
| word_key = <Word: G64>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePathControlMode:
|
| exec_order = 200
|
| modal_group = 13
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodePathControlMode
Python Library Documentation: class GCodePathControlMode in module pygcode.gcodes
class GCodePathControlMode(GCode)
| GCodePathControlMode(*words, **params)
|
| Method resolution order:
| GCodePathControlMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 200
|
| modal_group = 13
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodePauseProgram
Python Library Documentation: class GCodePauseProgram in module pygcode.gcodes
class GCodePauseProgram(GCodeProgramControl)
| GCodePauseProgram(*words, **params)
|
| M0: Program Pause
|
| Method resolution order:
| GCodePauseProgram
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M00>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeProgramControl:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodePauseProgramOptional
Python Library Documentation: class GCodePauseProgramOptional in module pygcode.gcodes
class GCodePauseProgramOptional(GCodeProgramControl)
| GCodePauseProgramOptional(*words, **params)
|
| M1: Program Pause (optional)
|
| Method resolution order:
| GCodePauseProgramOptional
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M01>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeProgramControl:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodePlaneSelect
Python Library Documentation: class GCodePlaneSelect in module pygcode.gcodes
class GCodePlaneSelect(GCode)
| GCodePlaneSelect(*words, **params)
|
| Method resolution order:
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 150
|
| modal_group = 2
|
| normal = None
|
| normal_axis = None
|
| plane_axes = set()
|
| quat = None
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeProgramControl
Python Library Documentation: class GCodeProgramControl in module pygcode.gcodes
class GCodeProgramControl(GCode)
| GCodeProgramControl(*words, **params)
|
| Method resolution order:
| GCodeProgramControl
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 250
|
| modal_group = 104
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeProgramName
Python Library Documentation: class GCodeProgramName in module pygcode.gcodes
class GCodeProgramName(GCodeDefinition)
| GCodeProgramName(*words, **params)
|
| O: Program Name
|
| Method resolution order:
| GCodeProgramName
| GCodeDefinition
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| name
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| exec_order = 1
|
| word_letter = 'O'
|
| word_value_configurable = True
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
pygcode.gcodes.GCodeQuadraticSpline
Python Library Documentation: class GCodeQuadraticSpline in module pygcode.gcodes
class GCodeQuadraticSpline(GCodeMotion)
| GCodeQuadraticSpline(*words, **params)
|
| G5.1: Quadratic Spline
|
| Method resolution order:
| GCodeQuadraticSpline
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'I', 'J', 'U', ...}
|
| word_key = <Word: G05.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeRapidMove
Python Library Documentation: class GCodeRapidMove in module pygcode.gcodes
class GCodeRapidMove(GCodeMotion)
| GCodeRapidMove(*words, **params)
|
| G0: Rapid Move
|
| Method resolution order:
| GCodeRapidMove
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G00>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| param_letters = {'A', 'B', 'C', 'U', 'V', 'W', ...}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeResetCoordSystemOffset
Python Library Documentation: class GCodeResetCoordSystemOffset in module pygcode.gcodes
class GCodeResetCoordSystemOffset(GCodeNonModal)
| GCodeResetCoordSystemOffset(*words, **params)
|
| G92.1,G92.2: Reset Coordinate System Offset
|
| Method resolution order:
| GCodeResetCoordSystemOffset
| GCodeNonModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: G92.1>
|
| exec_order = 230
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_value_configurable = False
pygcode.gcodes.GCodeRestoreCoordSystemOffset
Python Library Documentation: class GCodeRestoreCoordSystemOffset in module pygcode.gcodes
class GCodeRestoreCoordSystemOffset(GCodeNonModal)
| GCodeRestoreCoordSystemOffset(*words, **params)
|
| G92.3: Restore Coordinate System Offset
|
| Method resolution order:
| GCodeRestoreCoordSystemOffset
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 230
|
| word_key = <Word: G92.3>
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeRigidTapping
Python Library Documentation: class GCodeRigidTapping in module pygcode.gcodes
class GCodeRigidTapping(GCodeMotion)
| GCodeRigidTapping(*words, **params)
|
| G33.1: Rigid Tapping
|
| Method resolution order:
| GCodeRigidTapping
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'K', 'U', 'V', ...}
|
| word_key = <Word: G33.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectCoordinateSystem
Python Library Documentation: class GCodeSelectCoordinateSystem in module pygcode.gcodes
class GCodeSelectCoordinateSystem(GCodeOtherModal)
| GCodeSelectCoordinateSystem(*words, **params)
|
| Select Coordinate System
|
| Method resolution order:
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = None
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectCoordinateSystem1
Python Library Documentation: class GCodeSelectCoordinateSystem1 in module pygcode.gcodes
class GCodeSelectCoordinateSystem1(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem1(*words, **params)
|
| Select Coordinate System 1
|
| Method resolution order:
| GCodeSelectCoordinateSystem1
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 1
|
| word_key = <Word: G54>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectCoordinateSystem2
Python Library Documentation: class GCodeSelectCoordinateSystem2 in module pygcode.gcodes
class GCodeSelectCoordinateSystem2(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem2(*words, **params)
|
| Select Coordinate System 2
|
| Method resolution order:
| GCodeSelectCoordinateSystem2
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 2
|
| word_key = <Word: G55>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectCoordinateSystem3
Python Library Documentation: class GCodeSelectCoordinateSystem3 in module pygcode.gcodes
class GCodeSelectCoordinateSystem3(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem3(*words, **params)
|
| Select Coordinate System 3
|
| Method resolution order:
| GCodeSelectCoordinateSystem3
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 3
|
| word_key = <Word: G56>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectCoordinateSystem4
Python Library Documentation: class GCodeSelectCoordinateSystem4 in module pygcode.gcodes
class GCodeSelectCoordinateSystem4(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem4(*words, **params)
|
| Select Coordinate System 4
|
| Method resolution order:
| GCodeSelectCoordinateSystem4
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 4
|
| word_key = <Word: G57>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectCoordinateSystem5
Python Library Documentation: class GCodeSelectCoordinateSystem5 in module pygcode.gcodes
class GCodeSelectCoordinateSystem5(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem5(*words, **params)
|
| Select Coordinate System 5
|
| Method resolution order:
| GCodeSelectCoordinateSystem5
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 5
|
| word_key = <Word: G58>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectCoordinateSystem6
Python Library Documentation: class GCodeSelectCoordinateSystem6 in module pygcode.gcodes
class GCodeSelectCoordinateSystem6(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem6(*words, **params)
|
| Select Coordinate System 6
|
| Method resolution order:
| GCodeSelectCoordinateSystem6
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 6
|
| word_key = <Word: G59>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectCoordinateSystem7
Python Library Documentation: class GCodeSelectCoordinateSystem7 in module pygcode.gcodes
class GCodeSelectCoordinateSystem7(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem7(*words, **params)
|
| Select Coordinate System 7
|
| Method resolution order:
| GCodeSelectCoordinateSystem7
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 7
|
| word_key = <Word: G59.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectCoordinateSystem8
Python Library Documentation: class GCodeSelectCoordinateSystem8 in module pygcode.gcodes
class GCodeSelectCoordinateSystem8(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem8(*words, **params)
|
| Select Coordinate System 8
|
| Method resolution order:
| GCodeSelectCoordinateSystem8
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 8
|
| word_key = <Word: G59.2>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectCoordinateSystem9
Python Library Documentation: class GCodeSelectCoordinateSystem9 in module pygcode.gcodes
class GCodeSelectCoordinateSystem9(GCodeSelectCoordinateSystem)
| GCodeSelectCoordinateSystem9(*words, **params)
|
| Select Coordinate System 9
|
| Method resolution order:
| GCodeSelectCoordinateSystem9
| GCodeSelectCoordinateSystem
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| coord_system_id = 9
|
| word_key = <Word: G59.3>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSelectCoordinateSystem:
|
| exec_order = 190
|
| modal_group = 12
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectTool
Python Library Documentation: class GCodeSelectTool in module pygcode.gcodes
class GCodeSelectTool(GCodeOtherModal)
| GCodeSelectTool(*words, **params)
|
| T: Select Tool
|
| Method resolution order:
| GCodeSelectTool
| GCodeOtherModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: T0>
|
| exec_order = 60
|
| modal_group = 203
|
| word_letter = 'T'
|
| word_value_configurable = True
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
pygcode.gcodes.GCodeSelectUVPlane
Python Library Documentation: class GCodeSelectUVPlane in module pygcode.gcodes
class GCodeSelectUVPlane(GCodePlaneSelect)
| GCodeSelectUVPlane(*words, **params)
|
| G17.1: select UV plane
|
| Method resolution order:
| GCodeSelectUVPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G17.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| normal = None
|
| normal_axis = None
|
| plane_axes = set()
|
| quat = None
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectVWPlane
Python Library Documentation: class GCodeSelectVWPlane in module pygcode.gcodes
class GCodeSelectVWPlane(GCodePlaneSelect)
| GCodeSelectVWPlane(*words, **params)
|
| G19.1: select VW plane
|
| Method resolution order:
| GCodeSelectVWPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G19.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| normal = None
|
| normal_axis = None
|
| plane_axes = set()
|
| quat = None
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectWUPlane
Python Library Documentation: class GCodeSelectWUPlane in module pygcode.gcodes
class GCodeSelectWUPlane(GCodePlaneSelect)
| GCodeSelectWUPlane(*words, **params)
|
| G18.1: select WU plane
|
| Method resolution order:
| GCodeSelectWUPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G18.1>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| normal = None
|
| normal_axis = None
|
| plane_axes = set()
|
| quat = None
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectXYPlane
Python Library Documentation: class GCodeSelectXYPlane in module pygcode.gcodes
class GCodeSelectXYPlane(GCodePlaneSelect)
| GCodeSelectXYPlane(*words, **params)
|
| G17: select XY plane (default)
|
| Method resolution order:
| GCodeSelectXYPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| normal = Vector3(0.00, 0.00, 1.00)
|
| normal_axis = 'Z'
|
| plane_axes = {'X', 'Y'}
|
| quat = Quaternion(real=1.00, imag=<0.00, 0.00, 0.00>)
|
| word_key = <Word: G17>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectYZPlane
Python Library Documentation: class GCodeSelectYZPlane in module pygcode.gcodes
class GCodeSelectYZPlane(GCodePlaneSelect)
| GCodeSelectYZPlane(*words, **params)
|
| G19: select YZ plane
|
| Method resolution order:
| GCodeSelectYZPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| normal = Vector3(1.00, 0.00, 0.00)
|
| normal_axis = 'X'
|
| plane_axes = {'Y', 'Z'}
|
| quat = Quaternion(real=0.50, imag=<0.50, 0.50, 0.50>)
|
| word_key = <Word: G19>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSelectZXPlane
Python Library Documentation: class GCodeSelectZXPlane in module pygcode.gcodes
class GCodeSelectZXPlane(GCodePlaneSelect)
| GCodeSelectZXPlane(*words, **params)
|
| G18: select ZX plane
|
| Method resolution order:
| GCodeSelectZXPlane
| GCodePlaneSelect
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| normal = Vector3(0.00, 1.00, 0.00)
|
| normal_axis = 'Y'
|
| plane_axes = {'X', 'Z'}
|
| quat = Quaternion(real=0.50, imag=<-0.50, -0.50, -0.50>)
|
| word_key = <Word: G18>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodePlaneSelect:
|
| exec_order = 150
|
| modal_group = 2
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSet
Python Library Documentation: class GCodeSet in module pygcode.gcodes
class GCodeSet(GCodeNonModal)
| GCodeSet(*words, **params)
|
| G10: Set stuff
|
| Method resolution order:
| GCodeSet
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 230
|
| param_letters = {'A', 'B', 'C', 'L', 'P', 'Q', ...}
|
| word_key = <Word: G10>
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSetPredefinedPosition
Python Library Documentation: class GCodeSetPredefinedPosition in module pygcode.gcodes
class GCodeSetPredefinedPosition(GCodeNonModal)
| GCodeSetPredefinedPosition(*words, **params)
|
| G28.1,G30.1: Set Predefined Position
|
| Method resolution order:
| GCodeSetPredefinedPosition
| GCodeNonModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: G28.1>
|
| exec_order = 230
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_value_configurable = False
pygcode.gcodes.GCodeSpeedAndFeedOverrideOff
Python Library Documentation: class GCodeSpeedAndFeedOverrideOff in module pygcode.gcodes
class GCodeSpeedAndFeedOverrideOff(GCodeOtherModal)
| GCodeSpeedAndFeedOverrideOff(*words, **params)
|
| M49: Speed and Feed Override Control Off
|
| Method resolution order:
| GCodeSpeedAndFeedOverrideOff
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| modal_group = 109
|
| word_key = <Word: M49>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSpeedAndFeedOverrideOn
Python Library Documentation: class GCodeSpeedAndFeedOverrideOn in module pygcode.gcodes
class GCodeSpeedAndFeedOverrideOn(GCodeOtherModal)
| GCodeSpeedAndFeedOverrideOn(*words, **params)
|
| M48: Speed and Feed Override Control On
|
| Method resolution order:
| GCodeSpeedAndFeedOverrideOn
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| modal_group = 109
|
| word_key = <Word: M48>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSpindle
Python Library Documentation: class GCodeSpindle in module pygcode.gcodes
class GCodeSpindle(GCode)
| GCodeSpindle(*words, **params)
|
| Method resolution order:
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSpindleConstantSurfaceSpeedMode
Python Library Documentation: class GCodeSpindleConstantSurfaceSpeedMode in module pygcode.gcodes
class GCodeSpindleConstantSurfaceSpeedMode(GCodeSpindleSpeedMode)
| GCodeSpindleConstantSurfaceSpeedMode(*words, **params)
|
| G96: Spindle Constant Surface Speed
|
| Method resolution order:
| GCodeSpindleConstantSurfaceSpeedMode
| GCodeSpindleSpeedMode
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D', 'S'}
|
| word_key = <Word: G96>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindleSpeedMode:
|
| modal_group = 14
|
| word_letter = 'G'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSpindleRPMMode
Python Library Documentation: class GCodeSpindleRPMMode in module pygcode.gcodes
class GCodeSpindleRPMMode(GCodeSpindleSpeedMode)
| GCodeSpindleRPMMode(*words, **params)
|
| G97: Spindle RPM Speed
|
| Method resolution order:
| GCodeSpindleRPMMode
| GCodeSpindleSpeedMode
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'D'}
|
| word_key = <Word: G97>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindleSpeedMode:
|
| modal_group = 14
|
| word_letter = 'G'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSpindleSpeed
Python Library Documentation: class GCodeSpindleSpeed in module pygcode.gcodes
class GCodeSpindleSpeed(GCodeOtherModal)
| GCodeSpindleSpeed(*words, **params)
|
| S: Set Spindle Speed
|
| Method resolution order:
| GCodeSpindleSpeed
| GCodeOtherModal
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: S0>
|
| exec_order = 50
|
| modal_group = 202
|
| word_letter = 'S'
|
| word_value_configurable = True
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
pygcode.gcodes.GCodeSpindleSpeedMode
Python Library Documentation: class GCodeSpindleSpeedMode in module pygcode.gcodes
class GCodeSpindleSpeedMode(GCodeSpindle)
| GCodeSpindleSpeedMode(*words, **params)
|
| Method resolution order:
| GCodeSpindleSpeedMode
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 14
|
| word_letter = 'G'
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSpindleSpeedOverride
Python Library Documentation: class GCodeSpindleSpeedOverride in module pygcode.gcodes
class GCodeSpindleSpeedOverride(GCodeOtherModal)
| GCodeSpindleSpeedOverride(*words, **params)
|
| M51: Spindle Speed Override Control
|
| Method resolution order:
| GCodeSpindleSpeedOverride
| GCodeOtherModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 120
|
| param_letters = {'P'}
|
| word_key = <Word: M51>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeSpindleSyncMotion
Python Library Documentation: class GCodeSpindleSyncMotion in module pygcode.gcodes
class GCodeSpindleSyncMotion(GCodeMotion)
| GCodeSpindleSyncMotion(*words, **params)
|
| G33: Spindle Synchronized Motion
|
| Method resolution order:
| GCodeSpindleSyncMotion
| GCodeMotion
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'A', 'B', 'C', 'K', 'U', 'V', ...}
|
| word_key = <Word: G33>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeStartSpindle
Python Library Documentation: class GCodeStartSpindle in module pygcode.gcodes
class GCodeStartSpindle(GCodeSpindle)
| GCodeStartSpindle(*words, **params)
|
| M3,M4: Start Spindle Clockwise
|
| Method resolution order:
| GCodeStartSpindle
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 107
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeStartSpindleCCW
Python Library Documentation: class GCodeStartSpindleCCW in module pygcode.gcodes
class GCodeStartSpindleCCW(GCodeStartSpindle)
| GCodeStartSpindleCCW(*words, **params)
|
| M4: Start Spindle Counter-Clockwise
|
| Method resolution order:
| GCodeStartSpindleCCW
| GCodeStartSpindle
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M04>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeStartSpindle:
|
| modal_group = 107
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeStartSpindleCW
Python Library Documentation: class GCodeStartSpindleCW in module pygcode.gcodes
class GCodeStartSpindleCW(GCodeStartSpindle)
| GCodeStartSpindleCW(*words, **params)
|
| M3: Start Spindle Clockwise
|
| Method resolution order:
| GCodeStartSpindleCW
| GCodeStartSpindle
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: M03>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeStartSpindle:
|
| modal_group = 107
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeStopSpindle
Python Library Documentation: class GCodeStopSpindle in module pygcode.gcodes
class GCodeStopSpindle(GCodeSpindle)
| GCodeStopSpindle(*words, **params)
|
| M5: Stop Spindle
|
| Method resolution order:
| GCodeStopSpindle
| GCodeSpindle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| modal_group = 107
|
| word_key = <Word: M05>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeSpindle:
|
| exec_order = 90
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeStraightProbe
Python Library Documentation: class GCodeStraightProbe in module pygcode.gcodes
class GCodeStraightProbe(GCodeMotion)
| GCodeStraightProbe(*words, **params)
|
| G38.2-G38.5: Straight Probe
|
| Method resolution order:
| GCodeStraightProbe
| GCodeMotion
| GCode
| builtins.object
|
| Class methods defined here:
|
| word_matches(w)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_word = <Word: G38.2>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeMotion:
|
| exec_order = 242
|
| modal_group = 1
|
| param_letters = {'A', 'B', 'C', 'U', 'V', 'W', ...}
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_value_configurable = False
pygcode.gcodes.GCodeThreadingCycle
Python Library Documentation: class GCodeThreadingCycle in module pygcode.gcodes
class GCodeThreadingCycle(GCodeCannedCycle)
| GCodeThreadingCycle(*words, **params)
|
| G76: Threading Cycle
|
| Method resolution order:
| GCodeThreadingCycle
| GCodeCannedCycle
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'E', 'H', 'I', 'J', 'K', 'L', ...}
|
| word_key = <Word: G76>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeCannedCycle:
|
| exec_order = 242
|
| modal_group = 1
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeToolChange
Python Library Documentation: class GCodeToolChange in module pygcode.gcodes
class GCodeToolChange(GCodeNonModal)
| GCodeToolChange(*words, **params)
|
| M6: Tool Change
|
| Method resolution order:
| GCodeToolChange
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 80
|
| param_letters = {'T'}
|
| word_key = <Word: M06>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeToolLength
Python Library Documentation: class GCodeToolLength in module pygcode.gcodes
class GCodeToolLength(GCode)
| GCodeToolLength(*words, **params)
|
| Method resolution order:
| GCodeToolLength
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 180
|
| modal_group = 8
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeToolLengthOffset
Python Library Documentation: class GCodeToolLengthOffset in module pygcode.gcodes
class GCodeToolLengthOffset(GCodeToolLength)
| GCodeToolLengthOffset(*words, **params)
|
| G43: Tool Length Offset
|
| Method resolution order:
| GCodeToolLengthOffset
| GCodeToolLength
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'H'}
|
| word_key = <Word: G43>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeToolLength:
|
| exec_order = 180
|
| modal_group = 8
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeToolSetCurrent
Python Library Documentation: class GCodeToolSetCurrent in module pygcode.gcodes
class GCodeToolSetCurrent(GCodeNonModal)
| GCodeToolSetCurrent(*words, **params)
|
| M61: Set Current Tool
|
| Method resolution order:
| GCodeToolSetCurrent
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 80
|
| param_letters = {'Q'}
|
| word_key = <Word: M61>
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeUnit
Python Library Documentation: class GCodeUnit in module pygcode.gcodes
class GCodeUnit(GCode)
| GCodeUnit(*words, **params)
|
| Method resolution order:
| GCodeUnit
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 160
|
| modal_group = 6
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_key = None
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeUnitsPerMinuteMode
Python Library Documentation: class GCodeUnitsPerMinuteMode in module pygcode.gcodes
class GCodeUnitsPerMinuteMode(GCodeFeedRateMode)
| GCodeUnitsPerMinuteMode(*words, **params)
|
| G94: Units Per MinuteMode
|
| Method resolution order:
| GCodeUnitsPerMinuteMode
| GCodeFeedRateMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G94>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeFeedRateMode:
|
| exec_order = 30
|
| modal_group = 5
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeUnitsPerRevolution
Python Library Documentation: class GCodeUnitsPerRevolution in module pygcode.gcodes
class GCodeUnitsPerRevolution(GCodeFeedRateMode)
| GCodeUnitsPerRevolution(*words, **params)
|
| G95: Units Per Revolution
|
| Method resolution order:
| GCodeUnitsPerRevolution
| GCodeFeedRateMode
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| word_key = <Word: G95>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeFeedRateMode:
|
| exec_order = 30
|
| modal_group = 5
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeUseInches
Python Library Documentation: class GCodeUseInches in module pygcode.gcodes
class GCodeUseInches(GCodeUnit)
| GCodeUseInches(*words, **params)
|
| G20: use inches for length units
|
| Method resolution order:
| GCodeUseInches
| GCodeUnit
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| unit_id = 0
|
| word_key = <Word: G20>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeUnit:
|
| exec_order = 160
|
| modal_group = 6
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeUseMillimeters
Python Library Documentation: class GCodeUseMillimeters in module pygcode.gcodes
class GCodeUseMillimeters(GCodeUnit)
| GCodeUseMillimeters(*words, **params)
|
| G21: use millimeters for length units
|
| Method resolution order:
| GCodeUseMillimeters
| GCodeUnit
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| unit_id = 1
|
| word_key = <Word: G21>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeUnit:
|
| exec_order = 160
|
| modal_group = 6
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| param_letters = set()
|
| word_letter = 'G'
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeUserDefined
Python Library Documentation: class GCodeUserDefined in module pygcode.gcodes
class GCodeUserDefined(GCodeNonModal)
| GCodeUserDefined(*words, **params)
|
| M101-M199: User Defined Commands
|
| Method resolution order:
| GCodeUserDefined
| GCodeNonModal
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| exec_order = 130
|
| modal_group = 110
|
| param_letters = {'P', 'Q'}
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_param_letters = set()
|
| word_key = None
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeWaitOnInput
Python Library Documentation: class GCodeWaitOnInput in module pygcode.gcodes
class GCodeWaitOnInput(GCodeIO)
| GCodeWaitOnInput(*words, **params)
|
| M66: Wait on Input
|
| Method resolution order:
| GCodeWaitOnInput
| GCodeIO
| GCode
| builtins.object
|
| Data and other attributes defined here:
|
| param_letters = {'E', 'L', 'P', 'Q'}
|
| word_key = <Word: M66>
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCodeIO:
|
| exec_order = 70
|
| word_letter = 'M'
|
| ----------------------------------------------------------------------
| Methods inherited from GCode:
|
| __eq__(self, other)
| Return self==value.
|
| __ge__(self, other)
| Return self>=value.
|
| __getattr__(self, key)
|
| __gt__(self, other)
| Return self>value.
|
| __init__(self, *words, **params)
| :param word: Word instance defining gcode (eg: Word('G0') for rapid movement)
| :param params: list of Word instances (eg: Word('X-1.2') as x-coordinate)
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __ne__(self, other)
| Return self!=value.
|
| __repr__(self)
| Return repr(self).
|
| __setattr__(self, key, value)
| Implement setattr(self, name, value).
|
| __str__(self)
| String representation of gcode, as it would be seen in a .gcode file
|
| add_parameter(self, word)
| Add given word as a parameter for this gcode
| :param word: Word instance
|
| assert_params(self)
| Assert validity of gcode's parameters.
| This verification is irrespective of machine, or machine's state;
| verification is g-code language-based verification
| :raises: GCodeParameterError
|
| get_param_dict(self, letters=None, lc=False)
| Get gcode parameters as a dict
| gcode parameter like "X3.1, Y-2" would return {'X': 3.1, 'Y': -2}
| :param letters: iterable whitelist of letters to include as dict keys
| :param lc: lower case parameter letters
| :return: dict of gcode parameters' (letter, value) pairs
|
| modal_copy(self)
| Copy of GCode instance containing only parameters listed in modal_param_letters
|
| process(self, machine)
| Process a GCode on the given Machine
| :param machine: Machine instance, to change state
| :return: GCodeEffect instance; effect the gcode just had on machine
|
| ----------------------------------------------------------------------
| Readonly properties inherited from GCode:
|
| description
|
| ----------------------------------------------------------------------
| Data descriptors inherited from GCode:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from GCode:
|
| __hash__ = None
|
| default_word = None
|
| modal_group = None
|
| modal_param_letters = set()
|
| word_matches = None
|
| word_value_configurable = False
pygcode.gcodes.GCodeWordStrError
Python Library Documentation: class GCodeWordStrError in module pygcode.exceptions class GCodeWordStrError(builtins.Exception) | Raised when issues found while parsing a word string | | Method resolution order: | GCodeWordStrError | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Methods inherited from builtins.Exception: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.Exception: | | __new__(*args, **kwargs) class method of builtins.Exception | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | add_note(...) | Exception.add_note(note) -- | add a note to the exception | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args
pygcode.gcodes.MODAL_GROUP_MAP
Python Library Documentation: dict object
class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| Methods defined here:
|
| __contains__(self, key, /)
| True if the dictionary has the specified key, else False.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the dict keys.
|
| __ror__(self, value, /)
| Return value|self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| D.clear() -> None. Remove all items from D.
|
| copy(...)
| D.copy() -> a shallow copy of D
|
| get(self, key, default=None, /)
| Return the value for key if key is in the dictionary, else default.
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
|
| If the key is not found, return the default if given; otherwise,
| raise a KeyError.
|
| popitem(self, /)
| Remove and return a (key, value) pair as a 2-tuple.
|
| Pairs are returned in LIFO (last-in, first-out) order.
| Raises KeyError if the dict is empty.
|
| setdefault(self, key, default=None, /)
| Insert key with a value of default if key is not in the dictionary.
|
| Return the value for key if key is in the dictionary, else default.
|
| update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...)
| See PEP 585
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
pygcode.gcodes.Quaternion
Python Library Documentation: class Quaternion in module euclid3 class Quaternion(builtins.object) | Quaternion(w=1, x=0, y=0, z=0) | | Methods defined here: | | __abs__(self) | | __copy__(self) | | __imul__(self, other) | | __init__(self, w=1, x=0, y=0, z=0) | Initialize self. See help(type(self)) for accurate signature. | | __mul__(self, other) | | __repr__(self) | Return repr(self). | | conjugated(self) | | copy = __copy__(self) | | get_angle_axis(self) | | get_euler(self) | | get_matrix(self) | | identity(self) | | magnitude = __abs__(self) | | magnitude_squared(self) | | normalize(self) | | normalized(self) | | rotate_axis(self, angle, axis) | | rotate_euler(self, heading, attitude, bank) | | rotate_matrix(self, m) | | ---------------------------------------------------------------------- | Class methods defined here: | | new_identity() | # Static constructors | | new_interpolate(q1, q2, t) | | new_rotate_axis(angle, axis) | | new_rotate_euler(heading, attitude, bank) | | new_rotate_matrix(m) | | ---------------------------------------------------------------------- | Data descriptors defined here: | | w | | x | | y | | z
pygcode.gcodes.Vector3
Python Library Documentation: class Vector3 in module euclid3 class Vector3(builtins.object) | Vector3(x=0, y=0, z=0) | | Methods defined here: | | __abs__(self) | | __add__(self, other) | | __copy__(self) | | __div__(self, other) | | __eq__(self, other) | Return self==value. | | __floordiv__(self, other) | | __getattr__(self, name) | | __getitem__(self, key) | | __iadd__(self, other) | | __imul__(self, other) | | __init__(self, x=0, y=0, z=0) | Initialize self. See help(type(self)) for accurate signature. | | __iter__(self) | | __len__(self) | | __mul__(self, other) | | __ne__(self, other) | Return self!=value. | | __neg__(self) | | __nonzero__(self) | | __pos__ = __copy__(self) | | __radd__ = __add__(self, other) | | __rdiv__(self, other) | | __repr__(self) | Return repr(self). | | __rfloordiv__(self, other) | | __rmul__ = __mul__(self, other) | | __rsub__(self, other) | | __rtruediv__(self, other) | | __setitem__(self, key, value) | | __sub__(self, other) | | __truediv__(self, other) | | angle(self, other) | Return the angle to the vector other | | copy = __copy__(self) | | cross(self, other) | | dot(self, other) | | magnitude = __abs__(self) | | magnitude_squared(self) | | normalize(self) | | normalized(self) | | project(self, other) | Return one vector projected on the vector other | | reflect(self, normal) | | rotate_around(self, axis, theta) | Return the vector rotated around axis through angle theta. Right hand rule applies | | ---------------------------------------------------------------------- | Data descriptors defined here: | | x | | y | | z | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None
pygcode.gcodes.Word
Python Library Documentation: class Word in module pygcode.words class Word(builtins.object) | Word(*args) | | Methods defined here: | | __eq__(self, other) | Return self==value. | | __ge__(self, other) | Return self>=value. | | __gt__(self, other) | Return self>value. | | __hash__(self) | Return hash(self). | | __init__(self, *args) | Initialize self. See help(type(self)) for accurate signature. | | __le__(self, other) | Return self<=value. | | __lt__(self, other) | Return self<value. | | __ne__(self, other) | Return self!=value. | | __repr__(self) | Return repr(self). | | __str__(self) | Return str(self). | | ---------------------------------------------------------------------- | Readonly properties defined here: | | description | | value_str | Clean string representation, for consistent file output | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object | | value
pygcode.gcodes.build_maps
Python Library Documentation: function build_maps in module pygcode.gcodes
build_maps()
Populate _gcode_word_map and _gcode_function_list
pygcode.gcodes.copy
Python Library Documentation: function copy in module copy
copy(x)
Shallow copy operation on arbitrary Python objects.
See the module's __doc__ string for more info.
pygcode.gcodes.defaultdict
Python Library Documentation: class defaultdict in module collections class defaultdict(builtins.dict) | defaultdict(default_factory=None, /, [...]) --> dict with default factory | | The default factory is called without arguments to produce | a new value when a key is not present, in __getitem__ only. | A defaultdict compares equal to a dict with the same items. | All remaining arguments are treated the same as if they were | passed to the dict constructor, including keyword arguments. | | Method resolution order: | defaultdict | builtins.dict | builtins.object | | Methods defined here: | | __copy__(...) | D.copy() -> a shallow copy of D. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | __missing__(...) | __missing__(key) # Called by __getitem__ for missing key; pseudo-code: | if self.default_factory is None: raise KeyError((key,)) | self[key] = value = self.default_factory() | return value | | __or__(self, value, /) | Return self|value. | | __reduce__(...) | Return state information for pickling. | | __repr__(self, /) | Return repr(self). | | __ror__(self, value, /) | Return value|self. | | copy(...) | D.copy() -> a shallow copy of D. | | ---------------------------------------------------------------------- | Class methods defined here: | | __class_getitem__(...) | See PEP 585 | | ---------------------------------------------------------------------- | Data descriptors defined here: | | default_factory | Factory for default value called by __missing__(). | | ---------------------------------------------------------------------- | Methods inherited from builtins.dict: | | __contains__(self, key, /) | True if the dictionary has the specified key, else False. | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __ior__(self, value, /) | Return self|=value. | | __iter__(self, /) | Implement iter(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __reversed__(self, /) | Return a reverse iterator over the dict keys. | | __setitem__(self, key, value, /) | Set self[key] to value. | | __sizeof__(...) | D.__sizeof__() -> size of D in memory, in bytes | | clear(...) | D.clear() -> None. Remove all items from D. | | get(self, key, default=None, /) | Return the value for key if key is in the dictionary, else default. | | items(...) | D.items() -> a set-like object providing a view on D's items | | keys(...) | D.keys() -> a set-like object providing a view on D's keys | | pop(...) | D.pop(k[,d]) -> v, remove specified key and return the corresponding value. | | If the key is not found, return the default if given; otherwise, | raise a KeyError. | | popitem(self, /) | Remove and return a (key, value) pair as a 2-tuple. | | Pairs are returned in LIFO (last-in, first-out) order. | Raises KeyError if the dict is empty. | | setdefault(self, key, default=None, /) | Insert key with a value of default if key is not in the dictionary. | | Return the value for key if key is in the dictionary, else default. | | update(...) | D.update([E, ]**F) -> None. Update D from dict/iterable E and F. | If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] | If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v | In either case, this is followed by: for k in F: D[k] = F[k] | | values(...) | D.values() -> an object providing a view on D's values | | ---------------------------------------------------------------------- | Class methods inherited from builtins.dict: | | fromkeys(iterable, value=None, /) | Create a new dictionary with keys from iterable and values set to value. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.dict: | | __new__(*args, **kwargs) class method of builtins.dict | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data and other attributes inherited from builtins.dict: | | __hash__ = None
pygcode.gcodes.quat2coord_system
Python Library Documentation: function quat2coord_system in module pygcode.utils
quat2coord_system(origin1, origin2, align1, align2)
Calculate Quaternion to apply to any vector to re-orientate it to another
(target) coordinate system.
(note: both origin and align coordinate systems must use right-hand-rule)
:param origin1: origin(1|2) are perpendicular vectors in the original coordinate system
:param origin2: see origin1
:param align1: align(1|2) are 2 perpendicular vectors in the target coordinate system
:param align2: see align1
:return: Quaternion such that q * origin1 = align1, and q * origin2 = align2
pygcode.gcodes.split_gcodes
Python Library Documentation: function split_gcodes in module pygcode.gcodes
split_gcodes(gcode_list, splitter_class, sort_list=True)
Splits a list of GCode instances into 3, the center list containing the splitter_class gcode
:param gcode_list: list of GCode instances to split
:param splitter_class: class of gcode identifying split from left to right
:return: list of: [[<gcodes before splitter>], [<splitter instance>], [<gcodes after splitter>]]
pygcode.gcodes.text2gcodes
Python Library Documentation: function text2gcodes in module pygcode.gcodes
text2gcodes(text)
Convert text to GCode instances (must be fully formed; no modal parameters)
:param text: line from a g-code file
:return: tuple([<GCode>, <GCode>, ...], list(<unused words>))
pygcode.gcodes.text2words
Python Library Documentation: function text2words in module pygcode.words
text2words(block_text)
Iterate through block text yielding Word instances
:param block_text: text for given block with comments removed
pygcode.gcodes.word_gcode_class
Python Library Documentation: function word_gcode_class in module pygcode.gcodes
word_gcode_class(word, exhaustive=False)
Map word to corresponding GCode class
:param word: Word instance
:param exhausitve: if True, all words are tested; not just 'GMFST'
:return: class inheriting GCode
pygcode.gcodes.words2gcodes
Python Library Documentation: function words2gcodes in module pygcode.gcodes
words2gcodes(words)
Group words into g-codes (includes both G & M codes)
:param words: list of Word instances
:return: tuple([<GCode>, <GCode>, ...], list(<unused words>))