first half of the refactor adding getters and setters for init created properties

9 files changed, 991 insertions, 160 deletions

diff --git a/python/architecture.py b/python/architecture.py
index c2f28a86..2d81beb0 100644
--- a/python/architecture.py
+++ b/python/architecture.py
@@ -2648,7 +2648,7 @@ class CoreArchitecture(Architecture):
 
 class ArchitectureHook(CoreArchitecture):
 	def __init__(self, base_arch):
-		self.base_arch = base_arch
+		self._base_arch = base_arch
 		super(ArchitectureHook, self).__init__(base_arch.handle)
 
 		# To improve performance of simpler hooks, use null callback for functions that are not being overridden
@@ -2677,17 +2677,53 @@ class ArchitectureHook(CoreArchitecture):
 
 	def register(self):
 		self.__class__._registered_cb = self._cb
-		self.handle = core.BNRegisterArchitectureHook(self.base_arch.handle, self._cb)
+		self.handle = core.BNRegisterArchitectureHook(self._base_arch.handle, self._cb)
+
+	@property
+	def base_arch(self):
+		""" """
+		return self._base_arch
+
+	@base_arch.setter
+	def base_arch(self, value):
+		self._base_arch = value
 
 
 class ReferenceSource(object):
 	def __init__(self, func, arch, addr):
-		self.function = func
-		self.arch = arch
-		self.address = addr
+		self._function = func
+		self._arch = arch
+		self._address = addr
 
 	def __repr__(self):
-		if self.arch:
-			return "<ref: %s@%#x>" % (self.arch.name, self.address)
+		if self._arch:
+			return "<ref: %s@%#x>" % (self._arch.name, self._address)
 		else:
-			return "<ref: %#x>" % self.address
+			return "<ref: %#x>" % self._address
+
+	@property
+	def function(self):
+		""" """
+		return self._function
+
+	@function.setter
+	def function(self, value):
+		self._function = value
+
+	@property
+	def arch(self):
+		""" """
+		return self._arch
+
+	@arch.setter
+	def arch(self, value):
+		self._arch = value
+
+	@property
+	def address(self):
+		""" """
+		return self._address
+
+	@address.setter
+	def address(self, value):
+		self._address = value
diff --git a/python/basicblock.py b/python/basicblock.py
index 5730bab5..14784c81 100644
--- a/python/basicblock.py
+++ b/python/basicblock.py
@@ -33,27 +33,73 @@ from binaryninja import range
 
 class BasicBlockEdge(object):
 	def __init__(self, branch_type, source, target, back_edge, fall_through):
-		self.type = branch_type
-		self.source = source
-		self.target = target
-		self.back_edge = back_edge
-		self.fall_through = fall_through
+		self._type = branch_type
+		self._source = source
+		self._target = target
+		self._back_edge = back_edge
+		self._fall_through = fall_through
 
 	def __eq__(self, value):
 		if not isinstance(value, BasicBlockEdge):
 			return False
-		return (self.type, self.source, self.target, self.back_edge, self.fall_through) == (value.type, value.source, value.target, value.back_edge, value.fall_through)
+		return (self._type, self._source, self._target, self._back_edge, self._fall_through) == (value.type, value.source, value.target, value.back_edge, value.fall_through)
 
 	def __hash__(self):
-		return hash((self.type, self.source, self.target, self.back_edge, self.fall_through))
+		return hash((self._type, self._source, self._target, self.back_edge, self.fall_through))
 
 	def __repr__(self):
-		if self.type == BranchType.UnresolvedBranch:
-			return "<%s>" % BranchType(self.type).name
-		elif self.target.arch:
-			return "<%s: %s@%#x>" % (BranchType(self.type).name, self.target.arch.name, self.target.start)
+		if self._type == BranchType.UnresolvedBranch:
+			return "<%s>" % BranchType(self._type).name
+		elif self._target.arch:
+			return "<%s: %s@%#x>" % (BranchType(self._type).name, self._target.arch.name, self._target.start)
 		else:
-			return "<%s: %#x>" % (BranchType(self.type).name, self.target.start)
+			return "<%s: %#x>" % (BranchType(self._type).name, self._target.start)
+
+	@property
+	def type(self):
+		""" """
+		return self._type
+
+	@type.setter
+	def type(self, value):
+		self._type = value
+
+	@property
+	def source(self):
+		""" """
+		return self._source
+
+	@source.setter
+	def source(self, value):
+		self._source = value
+
+	@property
+	def target(self):
+		""" """
+		return self._target
+
+	@target.setter
+	def target(self, value):
+		self._target = value
+
+	@property
+	def back_edge(self):
+		""" """
+		return self._back_edge
+
+	@back_edge.setter
+	def back_edge(self, value):
+		self._back_edge = value
+
+	@property
+	def fall_through(self):
+		""" """
+		return self._fall_through
+
+	@fall_through.setter
+	def fall_through(self, value):
+		self._fall_through = value
+
 
 
 class BasicBlock(object):
@@ -88,7 +134,7 @@ class BasicBlock(object):
 		return int(core.BNGetBasicBlockLength(self.handle))
 
 	def __repr__(self):
-		arch = self.arch
+		arch = self._arch
 		if arch:
 			return "<block: %s@%#x-%#x>" % (arch.name, self.start, self.end)
 		else:
@@ -99,7 +145,7 @@ class BasicBlock(object):
 			# don't and instruction start cache the object is likely ephemeral
 			idx = self.start
 			while idx < self.end:
-				data = self.view.read(idx, min(self.arch.max_instr_length, self.end - idx))
+				data = self._view.read(idx, min(self._arch.max_instr_length, self.end - idx))
 				inst_text = self.arch.get_instruction_text(data, idx)
 				if inst_text[1] == 0:
 					break
@@ -107,7 +153,7 @@ class BasicBlock(object):
 				idx += inst_text[1]
 		else:
 			for start, length in zip(self._instStarts, self._instLengths):
-				inst_text = self.arch.get_instruction_text(self.view.read(start, length), start)
+				inst_text = self.arch.get_instruction_text(self._view.read(start, length), start)
 				if inst_text[1] == 0:
 					break
 				yield inst_text
@@ -116,7 +162,7 @@ class BasicBlock(object):
 		self._buildStartCache()
 		start = self._instStarts[i]
 		length = self._instLengths[i]
-		data = self.view.read(start, length)
+		data = self._view.read(start, length)
 		return self.arch.get_instruction_text(data, start)
 
 	def __hash__(self):
@@ -156,7 +202,7 @@ class BasicBlock(object):
 
 	@property
 	def view(self):
-		"""Binary view that contains the basic block (read-ony)"""
+		"""Binary view that contains the basic block (read-only)"""
 		if self._view is not None:
 			return self._view
 		self._view = self.function.view
@@ -228,7 +274,7 @@ class BasicBlock(object):
 		for i in range(0, count.value):
 			branch_type = BranchType(edges[i].type)
 			if edges[i].target:
-				target = self._create_instance(core.BNNewBasicBlockReference(edges[i].target), self.view)
+				target = self._create_instance(core.BNNewBasicBlockReference(edges[i].target), G)
 			else:
 				target = None
 			result.append(BasicBlockEdge(branch_type, target, self, edges[i].backEdge, edges[i].fallThrough))
@@ -341,7 +387,7 @@ class BasicBlock(object):
 	@property
 	def annotations(self):
 		"""List of automatic annotations for the start of this block (read-only)"""
-		return self.function.get_block_annotations(self.start, self.arch)
+		return self.function.get_block_annotations(self.start, self._arch)
 
 	@property
 	def disassembly_text(self):
@@ -461,3 +507,12 @@ class BasicBlock(object):
 		if isinstance(color, HighlightStandardColor):
 			color = highlight.HighlightColor(color)
 		core.BNSetUserBasicBlockHighlight(self.handle, color._get_core_struct())
+
+	@property
+	def view(self):
+		""" """
+		return self._view
+
+	@view.setter
+	def view(self, value):
+		self._view = value
diff --git a/python/binaryview.py b/python/binaryview.py
index 66c30d06..e98be02c 100644
--- a/python/binaryview.py
+++ b/python/binaryview.py
@@ -96,10 +96,10 @@ class BinaryDataNotification(object):
 
 class StringReference(object):
 	def __init__(self, bv, string_type, start, length):
-		self.type = string_type
-		self.start = start
-		self.length = length
-		self.view = bv
+		self._type = string_type
+		self._start = start
+		self._length = length
+		self._view = bv
 
 	@property
 	def value(self):
@@ -108,6 +108,42 @@ class StringReference(object):
 	def __repr__(self):
 		return "<%s: %#x, len %#x>" % (self.type, self.start, self.length)
 
+	@property
+	def type(self):
+		""" """
+		return self._type
+
+	@type.setter
+	def type(self, value):
+		self._type = value
+
+	@property
+	def start(self):
+		""" """
+		return self._start
+
+	@start.setter
+	def start(self, value):
+		self._start = value
+
+	@property
+	def length(self):
+		""" """
+		return self._length
+
+	@length.setter
+	def length(self, value):
+		self._length = value
+
+	@property
+	def view(self):
+		""" """
+		return self._view
+
+	@view.setter
+	def view(self, value):
+		self._view = value
+
 
 _pending_analysis_completion_events = {}
 class AnalysisCompletionEvent(object):
@@ -125,8 +161,8 @@ class AnalysisCompletionEvent(object):
 		>>>
 	"""
 	def __init__(self, view, callback):
-		self.view = view
-		self.callback = callback
+		self._view = view
+		self._callback = callback
 		self._cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p)(self._notify)
 		self.handle = core.BNAddAnalysisCompletionEvent(self.view.handle, None, self._cb)
 		global _pending_analysis_completion_events
@@ -152,42 +188,122 @@ class AnalysisCompletionEvent(object):
 
 	def cancel(self):
 		"""
-		.. warning: This method should only be used when the system is being
-		shut down and no further analysis should be done afterward.
+		.. warning: This method should only be used when the system is being shut down and no further analysis should be done afterward.
 		"""
-		self.callback = self._empty_callback
+		self._callback = self._empty_callback
 		core.BNCancelAnalysisCompletionEvent(self.handle)
 		global _pending_analysis_completion_events
 		if id(self) in _pending_analysis_completion_events:
 			del _pending_analysis_completion_events[id(self)]
 
+	@property
+	def view(self):
+		""" """
+		return self._view
+
+	@view.setter
+	def view(self, value):
+		self._view = value
+
+	@property
+	def callback(self):
+		""" """
+		return self._callback
+
+	@callback.setter
+	def callback(self, value):
+		self._callback = value
+
 
 class ActiveAnalysisInfo(object):
 	def __init__(self, func, analysis_time, update_count, submit_count):
-		self.func = func
-		self.analysis_time = analysis_time
-		self.update_count = update_count
-		self.submit_count = submit_count
+		self._func = func
+		self._analysis_time = analysis_time
+		self._update_count = update_count
+		self._submit_count = submit_count
 
 	def __repr__(self):
 		return "<ActiveAnalysisInfo %s, analysis_time %d, update_count %d, submit_count %d>" % (self.func, self.analysis_time, self.update_count, self.submit_count)
 
+	@property
+	def func(self):
+		""" """
+		return self._func
+
+	@func.setter
+	def func(self, value):
+		self._func = value
+
+	@property
+	def analysis_time(self):
+		""" """
+		return self._analysis_time
+
+	@analysis_time.setter
+	def analysis_time(self, value):
+		self._analysis_time = value
+
+	@property
+	def update_count(self):
+		""" """
+		return self._update_count
+
+	@update_count.setter
+	def update_count(self, value):
+		self._update_count = value
+
+	@property
+	def submit_count(self):
+		""" """
+		return self._submit_count
+
+	@submit_count.setter
+	def submit_count(self, value):
+		self._submit_count = value
+
 
 class AnalysisInfo(object):
 	def __init__(self, state, analysis_time, active_info):
-		self.state = AnalysisState(state)
-		self.analysis_time = analysis_time
-		self.active_info = active_info
+		self._state = AnalysisState(state)
+		self._analysis_time = analysis_time
+		self._active_info = active_info
 
 	def __repr__(self):
 		return "<AnalysisInfo %s, analysis_time %d, active_info %s>" % (self.state, self.analysis_time, self.active_info)
 
+	@property
+	def state(self):
+		""" """
+		return self._state
+
+	@state.setter
+	def state(self, value):
+		self._state = value
+
+	@property
+	def analysis_time(self):
+		""" """
+		return self._analysis_time
+
+	@analysis_time.setter
+	def analysis_time(self, value):
+		self._analysis_time = value
+
+	@property
+	def analysis_info(self):
+		""" """
+		return self._analysis_info
+
+	@analysis_info.setter
+	def analysis_info(self, value):
+		self._analysis_info = value
+
 
 class AnalysisProgress(object):
 	def __init__(self, state, count, total):
-		self.state = state
-		self.count = count
-		self.total = total
+		self._state = state
+		self._count = count
+		self._total = total
 
 	def __str__(self):
 		if self.state == AnalysisState.DisassembleState:
@@ -201,13 +317,40 @@ class AnalysisProgress(object):
 	def __repr__(self):
 		return "<progress: %s>" % str(self)
 
+	@property
+	def state(self):
+		""" """
+		return self._state
+
+	@state.setter
+	def state(self, value):
+		self._state = value
+
+	@property
+	def count(self):
+		""" """
+		return self._count
+
+	@count.setter
+	def count(self, value):
+		self._count = value
+
+	@property
+	def total(self):
+		""" """
+		return self._total
+
+	@total.setter
+	def total(self, value):
+		self._total = value
+
 
 class DataVariable(object):
 	def __init__(self, addr, var_type, auto_discovered, view=None):
-		self.address = addr
-		self.type = var_type
-		self.auto_discovered = auto_discovered
-		self.view = view
+		self._address = addr
+		self._type = var_type
+		self._auto_discovered = auto_discovered
+		self._view = view
 
 	@property
 	def data_refs_from(self):
@@ -230,11 +373,47 @@ class DataVariable(object):
 	def __repr__(self):
 		return "<var 0x%x: %s>" % (self.address, str(self.type))
 
+	@property
+	def address(self):
+		""" """
+		return self._address
+
+	@address.setter
+	def address(self, value):
+		self._address = value
+
+	@property
+	def type(self):
+		""" """
+		return self._type
+
+	@type.setter
+	def type(self, value):
+		self._type = value
+
+	@property
+	def auto_discovered(self):
+		""" """
+		return self._auto_discovered
+
+	@auto_discovered.setter
+	def auto_discovered(self, value):
+		self._auto_discovered = value
+
+	@property
+	def view(self):
+		""" """
+		return self._view
+
+	@view.setter
+	def view(self, value):
+		self._view = value
+
 
 class BinaryDataNotificationCallbacks(object):
 	def __init__(self, view, notify):
-		self.view = view
-		self.notify = notify
+		self._view = view
+		self._notify = notify
 		self._cb = core.BNBinaryDataNotification()
 		self._cb.context = 0
 		self._cb.dataWritten = self._cb.dataWritten.__class__(self._data_written)
@@ -353,6 +532,24 @@ class BinaryDataNotificationCallbacks(object):
 		except:
 			log.log_error(traceback.format_exc())
 
+	@property
+	def view(self):
+		""" """
+		return self._view
+
+	@view.setter
+	def view(self, value):
+		self._view = value
+
+	@property
+	def notify(self):
+		""" """
+		return self._notify
+
+	@notify.setter
+	def notify(self, value):
+		self._notify = value
+
 
 class _BinaryViewTypeMetaclass(type):
 
@@ -660,8 +857,8 @@ class Section(object):
 
 class AddressRange(object):
 	def __init__(self, start, end):
-		self.start = start
-		self.end = end
+		self._start = start
+		self._end = end
 
 	@property
 	def length(self):
@@ -673,6 +870,24 @@ class AddressRange(object):
 	def __repr__(self):
 		return "<%#x-%#x>" % (self.start, self.end)
 
+	@property
+	def start(self):
+		""" """
+		return self._start
+
+	@start.setter
+	def start(self, value):
+		self._start = value
+
+	@property
+	def end(self):
+		""" """
+		return self._end
+
+	@end.setter
+	def end(self, value):
+		self._end = value
+
 
 class _BinaryViewAssociatedDataStore(associateddatastore._AssociatedDataStore):
 	_defaults = {}
@@ -738,15 +953,15 @@ class BinaryView(object):
 		if handle is not None:
 			self.handle = core.handle_of_type(handle, core.BNBinaryView)
 			if file_metadata is None:
-				self.file = binaryninja.filemetadata.FileMetadata(handle=core.BNGetFileForView(handle))
+				self._file = binaryninja.filemetadata.FileMetadata(handle=core.BNGetFileForView(handle))
 			else:
-				self.file = file_metadata
+				self._file = file_metadata
 		elif self.__class__ is BinaryView:
 			binaryninja._init_plugins()
 			if file_metadata is None:
 				file_metadata = binaryninja.filemetadata.FileMetadata()
 			self.handle = core.BNCreateBinaryDataView(file_metadata.handle)
-			self.file = binaryninja.filemetadata.FileMetadata(handle=core.BNNewFileReference(file_metadata.handle))
+			self._file = binaryninja.filemetadata.FileMetadata(handle=core.BNNewFileReference(file_metadata.handle))
 		else:
 			binaryninja._init_plugins()
 			if not self.__class__._registered:
@@ -774,12 +989,12 @@ class BinaryView(object):
 			self._cb.isRelocatable = self._cb.isRelocatable.__class__(self._is_relocatable)
 			self._cb.getAddressSize = self._cb.getAddressSize.__class__(self._get_address_size)
 			self._cb.save = self._cb.save.__class__(self._save)
-			self.file = file_metadata
+			self._file = file_metadata
 			if parent_view is not None:
 				parent_view = parent_view.handle
 			self.handle = core.BNCreateCustomBinaryView(self.__class__.name, file_metadata.handle, parent_view, self._cb)
-		self.notifications = {}
-		self.next_address = None  # Do NOT try to access view before init() is called, use placeholder
+		self._notifications = {}
+		self._next_address = None  # Do NOT try to access view before init() is called, use placeholder
 
 	def __eq__(self, value):
 		if not isinstance(value, BinaryView):
@@ -945,37 +1160,64 @@ class BinaryView(object):
 	@property
 	def modified(self):
 		"""boolean modification state of the BinaryView (read/write)"""
-		return self.file.modified
+		return self._file.modified
 
 	@modified.setter
 	def modified(self, value):
-		self.file.modified = value
+		self._file.modified = value
 
 	@property
 	def analysis_changed(self):
 		"""boolean analysis state changed of the currently running analysis (read-only)"""
-		return self.file.analysis_changed
+		return self._file.analysis_changed
 
 	@property
 	def has_database(self):
 		"""boolean has a database been written to disk (read-only)"""
-		return self.file.has_database
+		return self._file.has_database
 
 	@property
 	def view(self):
-		return self.file.view
+		return self._file.view
 
 	@view.setter
 	def view(self, value):
-		self.file.view = value
+		self._file.view = value
 
 	@property
 	def offset(self):
-		return self.file.offset
+		return self._file.offset
 
 	@offset.setter
 	def offset(self, value):
-		self.file.offset = value
+		self._file.offset = value
+
+	@property
+	def file(self):
+		""":class:`.FileMetadata` backing the BinaryView """
+		return self._file
+
+	@file.setter
+	def file(self, value):
+		self._file = value
+
+	@property
+	def notifications(self):
+		""":class:`.FileMetadata` backing the BinaryView """
+		return self._notifications
+
+	@notifications.setter
+	def notifications(self, value):
+		self._notifications = value
+
+	@property
+	def next_address(self):
+		""":class:`.FileMetadata` backing the BinaryView """
+		return self._next_address
+
+	@next_address.setter
+	def next_address(self, value):
+		self._next_address = value
 
 	@property
 	def start(self):
@@ -994,7 +1236,7 @@ class BinaryView(object):
 
 	@property
 	def arch(self):
-		"""The architecture associated with the current BinaryView (read/write)"""
+		"""The architecture associated with the current :class:`.BinaryView` (read/write)"""
 		arch = core.BNGetDefaultArchitecture(self.handle)
 		if arch is None:
 			return None
@@ -1132,11 +1374,11 @@ class BinaryView(object):
 	@property
 	def saved(self):
 		"""boolean state of whether or not the file has been saved (read/write)"""
-		return self.file.saved
+		return self._file.saved
 
 	@saved.setter
 	def saved(self, value):
-		self.file.saved = value
+		self._file.saved = value
 
 	@property
 	def analysis_info(self):
@@ -1373,7 +1615,7 @@ class BinaryView(object):
 			size = "start %#x, len %#x" % (start, length)
 		else:
 			size = "len %#x" % length
-		filename = self.file.filename
+		filename = self._file.filename
 		if len(filename) > 0:
 			return "<BinaryView: '%s', %s>" % (filename, size)
 		return "<BinaryView: %s>" % (size)
@@ -1833,7 +2075,7 @@ class BinaryView(object):
 		:return: true on success, false on failure
 		:rtype: bool
 		"""
-		return self.file.create_database(filename, progress_func)
+		return self._file.create_database(filename, progress_func)
 
 	def save_auto_snapshot(self, progress_func=None):
 		"""
@@ -1845,7 +2087,7 @@ class BinaryView(object):
 		:return: True if it successfully saved the snapshot, False otherwise
 		:rtype: bool
 		"""
-		return self.file.save_auto_snapshot(progress_func)
+		return self._file.save_auto_snapshot(progress_func)
 
 	def get_view_of_type(self, name):
 		"""
@@ -1855,7 +2097,7 @@ class BinaryView(object):
 		:return: BinaryView object associated with the provided name or None on failure
 		:rtype: BinaryView or None
 		"""
-		return self.file.get_view_of_type(name)
+		return self._file.get_view_of_type(name)
 
 	def begin_undo_actions(self):
 		"""
@@ -1877,7 +2119,7 @@ class BinaryView(object):
 			'xor     eax, eax'
 			>>>
 		"""
-		self.file.begin_undo_actions()
+		self._file.begin_undo_actions()
 
 	def add_undo_action(self, action):
 		core.BNAddUndoAction(self.handle, action.__class__.name, action._cb)
@@ -1902,7 +2144,7 @@ class BinaryView(object):
 			'xor     eax, eax'
 			>>>
 		"""
-		self.file.commit_undo_actions()
+		self._file.commit_undo_actions()
 
 	def undo(self):
 		"""
@@ -1927,7 +2169,7 @@ class BinaryView(object):
 			'nop'
 			>>>
 		"""
-		self.file.undo()
+		self._file.undo()
 
 	def redo(self):
 		"""
@@ -1952,10 +2194,10 @@ class BinaryView(object):
 			'nop'
 			>>>
 		"""
-		self.file.redo()
+		self._file.redo()
 
 	def navigate(self, view, offset):
-		return self.file.navigate(view, offset)
+		return self._file.navigate(view, offset)
 
 	def read(self, addr, length):
 		"""
@@ -2880,6 +3122,7 @@ class BinaryView(object):
 			>>> bv.is_invert_branch_patch_available(0x100012ef)
 			True
 			>>>
+
 		"""
 		if arch is None:
 			arch = self.arch
@@ -3560,8 +3803,8 @@ class BinaryView(object):
 		"""
 		class LinearDisassemblyIterator(object):
 			def __init__(self, view, settings):
-				self.view = view
-				self.settings = settings
+				self._view = view
+				self._settings = settings
 
 			def __iter__(self):
 				pos = self.view.get_linear_disassembly_position_at(self.view.start, self.settings)
@@ -3572,6 +3815,25 @@ class BinaryView(object):
 					for line in lines:
 						yield line
 
+			@property
+			def view(self):
+				""" """
+				return self._view
+
+			@view.setter
+			def view(self, value):
+				self._view = value
+
+			@property
+			def settings(self):
+				""" """
+				return self._settings
+
+			@settings.setter
+			def settings(self, value):
+				self._settings = value
+
+
 		return iter(LinearDisassemblyIterator(self, settings))
 
 	def parse_type_string(self, text):
@@ -3942,7 +4204,7 @@ class BinaryView(object):
 
 	def get_address_input(self, prompt, title, current_address = None):
 		if current_address is None:
-			current_address = self.file.offset
+			current_address = self._file.offset
 		value = ctypes.c_ulonglong()
 		if not core.BNGetAddressInput(value, prompt, title, self.handle, current_address):
 			return None
diff --git a/python/callingconvention.py b/python/callingconvention.py
index ee42caca..92aa30f2 100644
--- a/python/callingconvention.py
+++ b/python/callingconvention.py
@@ -53,7 +53,7 @@ class CallingConvention(object):
 			if arch is None or name is None:
 				self.handle = None
 				raise ValueError("Must specify either handle or architecture and name")
-			self.arch = arch
+			self._arch = arch
 			self._pending_reg_lists = {}
 			self._cb = core.BNCustomCallingConvention()
 			self._cb.context = 0
@@ -443,3 +443,12 @@ class CallingConvention(object):
 			func_obj = func.handle
 		out_var = core.BNGetParameterVariableForIncomingVariable(self.handle, in_buf, func_obj)
 		return binaryninja.function.Variable(func, out_var.type, out_var.index, out_var.storage)
+
+	@property
+	def arch(self):
+		""" """
+		return self._arch
+
+	@arch.setter
+	def arch(self, value):
+		self._arch = value
diff --git a/python/databuffer.py b/python/databuffer.py
index 8644a75e..3d754090 100644
--- a/python/databuffer.py
+++ b/python/databuffer.py
@@ -34,6 +34,8 @@ class DataBuffer(object):
 			self.handle = core.handle_of_type(handle, core.BNDataBuffer)
 		elif isinstance(contents, int) or isinstance(contents, long):
 			self.handle = core.BNCreateDataBuffer(None, contents)
+		elif isinstance(contents, str):
+			self.handle = core.BNCreateDataBuffer(contents.encode(), len(contents.encode()))
 		elif isinstance(contents, DataBuffer):
 			self.handle = core.BNDuplicateDataBuffer(contents.handle)
 		else:
diff --git a/python/filemetadata.py b/python/filemetadata.py
index 74445a02..8c6b2cb7 100644
--- a/python/filemetadata.py
+++ b/python/filemetadata.py
@@ -86,7 +86,17 @@ class FileMetadata(object):
 			self.handle = core.BNCreateFileMetadata()
 			if filename is not None:
 				core.BNSetFilename(self.handle, str(filename))
-		self.nav = None
+		self._nav = None
+
+	@property
+	def nav(self):
+		"""
+		"""
+		return self._nav
+
+	@nav.setter
+	def nav(self, value):
+		self._nav = value
 
 	def __del__(self):
 		if self.navigation is not None:
@@ -192,12 +202,13 @@ class FileMetadata(object):
 
 	@property
 	def navigation(self):
-		return self.nav
+		"""Alias for nav"""
+		return self._nav
 
 	@navigation.setter
 	def navigation(self, value):
 		value._register(self.handle)
-		self.nav = value
+		self._nav = value
 
 	@property
 	def session_data(self):
diff --git a/python/flowgraph.py b/python/flowgraph.py
index 189b075c..a5ac686c 100644
--- a/python/flowgraph.py
+++ b/python/flowgraph.py
@@ -58,9 +58,10 @@ class FlowGraphNode(object):
 				raise ValueError("flow graph node must be associated with a graph")
 			handle = core.BNCreateFlowGraphNode(graph.handle)
 		self.handle = handle
+		self._graph = graph
 		self.graph = graph
-		if self.graph is None:
-			self.graph = FlowGraph(handle = core.BNGetFlowGraphNodeOwner(self.handle))
+		if self._graph is None:
+			self._graph = FlowGraph(handle = core.BNGetFlowGraphNodeOwner(self.handle))
 
 	def __del__(self):
 		if self.handle is not None:
@@ -77,6 +78,15 @@ class FlowGraphNode(object):
 		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
 
 	@property
+	def graph(self):
+		""" """
+		return self._graph
+
+	@graph.setter
+	def graph(self, value):
+		self._graph = value
+
+	@property
 	def basic_block(self):
 		"""Basic block associated with this part of the flow graph"""
 		block = core.BNGetFlowGraphBasicBlock(self.handle)
diff --git a/python/function.py b/python/function.py
index c33ac97f..9e018758 100644
--- a/python/function.py
+++ b/python/function.py
@@ -41,34 +41,54 @@ from binaryninja import range
 
 class LookupTableEntry(object):
 	def __init__(self, from_values, to_value):
-		self.from_values = from_values
-		self.to_value = to_value
+		self._from_values = from_values
+		self._to_value = to_value
 
 	def __repr__(self):
 		return "[%s] -> %#x" % (', '.join(["%#x" % i for i in self.from_values]), self.to_value)
 
+	@property
+	def from_values(self):
+		""" """
+		return self._from_values
+
+	@from_values.setter
+	def from_values(self, value):
+		""" """
+		self._from_values = value
+
+	@property
+	def to_values(self):
+		""" """
+		return self._to_values
+
+	@to_values.setter
+	def to_values(self, value):
+		""" """
+		self._to_values = value
+
 
 class RegisterValue(object):
 	def __init__(self, arch = None, value = None, confidence = types.max_confidence):
-		self.is_constant = False
+		self._is_constant = False
 		if value is None:
-			self.type = RegisterValueType.UndeterminedValue
+			self._type = RegisterValueType.UndeterminedValue
 		else:
-			self.type = RegisterValueType(value.state)
+			self._type = RegisterValueType(value.state)
 			if value.state == RegisterValueType.EntryValue:
-				self.arch = arch
+				self._arch = arch
 				if arch is not None:
-					self.reg = arch.get_reg_name(value.value)
+					self._reg = arch.get_reg_name(value.value)
 				else:
-					self.reg = value.value
+					self._reg = value.value
 			elif (value.state == RegisterValueType.ConstantValue) or (value.state == RegisterValueType.ConstantPointerValue):
-				self.value = value.value
-				self.is_constant = True
+				self._value = value.value
+				self._is_constant = True
 			elif value.state == RegisterValueType.StackFrameOffset:
-				self.offset = value.value
+				self._offset = value.value
 			elif value.state == RegisterValueType.ImportedAddressValue:
-				self.value = value.value
-		self.confidence = confidence
+				self._value = value.value
+		self._confidence = confidence
 
 	def __repr__(self):
 		if self.type == RegisterValueType.EntryValue:
@@ -150,33 +170,143 @@ class RegisterValue(object):
 		result.type = RegisterValueType.ReturnAddressValue
 		return result
 
+	@property
+	def is_constant(self):
+		""" """
+		return self._is_constant
+
+	@is_constant.setter
+	def is_constant(self, value):
+		""" """
+		self._is_constant = value
+
+	@property
+	def type(self):
+		""" """
+		return self._type
+
+	@type.setter
+	def type(self, value):
+		""" """
+		self._type = value
+
+	@property
+	def state(self):
+		""" """
+		return self._state
+
+	@state.setter
+	def state(self, value):
+		""" """
+		self._state = value
+
+	@property
+	def arch(self):
+		""" """
+		return self._arch
+
+	@arch.setter
+	def arch(self, value):
+		""" """
+		self._arch = value
+
+	@property
+	def reg(self):
+		""" """
+		return self._reg
+
+	@reg.setter
+	def reg(self, value):
+		""" """
+		self._reg = value
+
+	@property
+	def value(self):
+		""" """
+		return self._value
+
+	@value.setter
+	def value(self, value):
+		""" """
+		self._value = value
+
+	@property
+	def offset(self):
+		""" """
+		return self._offset
+
+	@offset.setter
+	def offset(self, value):
+		""" """
+		self._offset = value
+
+	@property
+	def confidence(self):
+		""" """
+		return self._confidence
+
+	@confidence.setter
+	def confidence(self, value):
+		""" """
+		self._confidence = value
+
 
 class ValueRange(object):
 	def __init__(self, start, end, step):
-		self.start = start
-		self.end = end
-		self.step = step
+		self._start = start
+		self._end = end
+		self._step = step
 
 	def __repr__(self):
 		if self.step == 1:
 			return "<range: %#x to %#x>" % (self.start, self.end)
 		return "<range: %#x to %#x, step %#x>" % (self.start, self.end, self.step)
 
+	@property
+	def start(self):
+		""" """
+		return self._start
+
+	@start.setter
+	def start(self, value):
+		""" """
+		self._start = value
+
+	@property
+	def end(self):
+		""" """
+		return self._end
+
+	@end.setter
+	def end(self, value):
+		""" """
+		self._end = value
+
+	@property
+	def step(self):
+		""" """
+		return self._step
+
+	@step.setter
+	def step(self, value):
+		""" """
+		self._step = value
+
 
 class PossibleValueSet(object):
 	def __init__(self, arch, value):
-		self.type = RegisterValueType(value.state)
+		self._type = RegisterValueType(value.state)
 		if value.state == RegisterValueType.EntryValue:
-			self.reg = arch.get_reg_name(value.value)
+			self._reg = arch.get_reg_name(value.value)
 		elif value.state == RegisterValueType.ConstantValue:
-			self.value = value.value
+			self._value = value.value
 		elif value.state == RegisterValueType.ConstantPointerValue:
-			self.value = value.value
+			self._value = value.value
 		elif value.state == RegisterValueType.StackFrameOffset:
-			self.offset = value.value
+			self._offset = value.value
 		elif value.state == RegisterValueType.SignedRangeValue:
-			self.offset = value.value
-			self.ranges = []
+			self._offset = value.value
+			self._ranges = []
 			for i in range(0, value.count):
 				start = value.ranges[i].start
 				end = value.ranges[i].end
@@ -185,28 +315,28 @@ class PossibleValueSet(object):
 					start |= ~((1 << 63) - 1)
 				if end & (1 << 63):
 					end |= ~((1 << 63) - 1)
-				self.ranges.append(ValueRange(start, end, step))
+				self._ranges.append(ValueRange(start, end, step))
 		elif value.state == RegisterValueType.UnsignedRangeValue:
-			self.offset = value.value
-			self.ranges = []
+			self._offset = value.value
+			self._ranges = []
 			for i in range(0, value.count):
 				start = value.ranges[i].start
 				end = value.ranges[i].end
 				step = value.ranges[i].step
-				self.ranges.append(ValueRange(start, end, step))
+				self._ranges.append(ValueRange(start, end, step))
 		elif value.state == RegisterValueType.LookupTableValue:
-			self.table = []
-			self.mapping = {}
+			self._table = []
+			self._mapping = {}
 			for i in range(0, value.count):
 				from_list = []
 				for j in range(0, value.table[i].fromCount):
 					from_list.append(value.table[i].fromValues[j])
-					self.mapping[value.table[i].fromValues[j]] = value.table[i].toValue
-				self.table.append(LookupTableEntry(from_list, value.table[i].toValue))
+					self._mapping[value.table[i].fromValues[j]] = value.table[i].toValue
+				self._table.append(LookupTableEntry(from_list, value.table[i].toValue))
 		elif (value.state == RegisterValueType.InSetOfValues) or (value.state == RegisterValueType.NotInSetOfValues):
-			self.values = set()
+			self._values = set()
 			for i in range(0, value.count):
-				self.values.add(value.valueSet[i])
+				self._values.add(value.valueSet[i])
 
 	def __repr__(self):
 		if self.type == RegisterValueType.EntryValue:
@@ -231,40 +361,184 @@ class PossibleValueSet(object):
 			return "<return address>"
 		return "<undetermined>"
 
+	@property
+	def type(self):
+		""" """
+		return self._type
+
+	@type.setter
+	def type(self, value):
+		""" """
+		self._type = value
+
+	@property
+	def reg(self):
+		""" """
+		return self._reg
+
+	@reg.setter
+	def reg(self, value):
+		""" """
+		self._reg = value
+
+	@property
+	def value(self):
+		""" """
+		return self._value
+
+	@value.setter
+	def value(self, value):
+		""" """
+		self._value = value
+
+	@property
+	def offset(self):
+		""" """
+		return self._offset
+
+	@offset.setter
+	def offset(self, value):
+		""" """
+		self._offset = value
+
+	@property
+	def ranges(self):
+		""" """
+		return self._ranges
+
+	@ranges.setter
+	def ranges(self, value):
+		""" """
+		self._ranges = value
+
+	@property
+	def table(self):
+		""" """
+		return self._table
+
+	@table.setter
+	def table(self, value):
+		""" """
+		self._table = value
+
+	@property
+	def table(self):
+		""" """
+		return self._table
+
+	@table.setter
+	def table(self, value):
+		""" """
+		self._table = value
+
+	@property
+	def mapping(self):
+		""" """
+		return self._mapping
+
+	@mapping.setter
+	def mapping(self, value):
+		""" """
+		self._mapping = value
+
+	@property
+	def values(self):
+		""" """
+		return self._values
+
+	@values.setter
+	def values(self, value):
+		""" """
+		self._values = value
+
 
 class StackVariableReference(object):
 	def __init__(self, src_operand, t, name, var, ref_ofs, size):
-		self.source_operand = src_operand
-		self.type = t
-		self.name = name
-		self.var = var
-		self.referenced_offset = ref_ofs
-		self.size = size
-		if self.source_operand == 0xffffffff:
-			self.source_operand = None
+		self._source_operand = src_operand
+		self._type = t
+		self._name = name
+		self._var = var
+		self._referenced_offset = ref_ofs
+		self._size = size
+		if self._source_operand == 0xffffffff:
+			self._source_operand = None
 
 	def __repr__(self):
-		if self.source_operand is None:
-			if self.referenced_offset != self.var.storage:
-				return "<ref to %s%+#x>" % (self.name, self.referenced_offset - self.var.storage)
-			return "<ref to %s>" % self.name
-		if self.referenced_offset != self.var.storage:
-			return "<operand %d ref to %s%+#x>" % (self.source_operand, self.name, self.var.storage)
-		return "<operand %d ref to %s>" % (self.source_operand, self.name)
+		if self._source_operand is None:
+			if self._referenced_offset != self._var.storage:
+				return "<ref to %s%+#x>" % (self._name, self._referenced_offset - self._var.storage)
+			return "<ref to %s>" % self._name
+		if self._referenced_offset != self._var.storage:
+			return "<operand %d ref to %s%+#x>" % (self._source_operand, self._name, self._var.storage)
+		return "<operand %d ref to %s>" % (self._source_operand, self._name)
+
+	@property
+	def source_operand(self):
+		""" """
+		return self._source_operand
+
+	@source_operand.setter
+	def source_operand(self, value):
+		self._source_operand = value
+
+	@property
+	def type(self):
+		""" """
+		return self._type
+
+	@type.setter
+	def type(self, value):
+		self._type = value
+
+	@property
+	def name(self):
+		""" """
+		return self._name
+
+	@name.setter
+	def name(self, value):
+		self._name = value
+
+	@property
+	def var(self):
+		""" """
+		return self._var
+
+	@var.setter
+	def var(self, value):
+		self._var = value
+
+	@property
+	def referenced_offset(self):
+		""" """
+		return self._referenced_offset
+
+	@referenced_offset.setter
+	def referenced_offset(self, value):
+		self._referenced_offset = value
+
+	@property
+	def size(self):
+		""" """
+		return self._size
+
+	@size.setter
+	def size(self, value):
+		self._size = value
 
 
 class Variable(object):
 	def __init__(self, func, source_type, index, storage, name = None, var_type = None):
-		self.function = func
-		self.source_type = VariableSourceType(source_type)
-		self.index = index
-		self.storage = storage
+		self._function = func
+		self._source_type = VariableSourceType(source_type)
+		self._index = index
+		self._storage = storage
 
 		var = core.BNVariable()
 		var.type = source_type
 		var.index = index
 		var.storage = storage
-		self.identifier = core.BNToVariableIdentifier(var)
+		self._identifier = core.BNToVariableIdentifier(var)
 
 		if func is not None:
 			if name is None:
@@ -276,8 +550,71 @@ class Variable(object):
 				else:
 					var_type = None
 
-		self.name = name
-		self.type = var_type
+		self._name = name
+		self._type = var_type
+
+	@property
+	def function(self):
+		""" """
+		return self._function
+
+	@function.setter
+	def function(self, value):
+		self._function = value
+
+	@property
+	def source_type(self):
+		""" """
+		return self._source_type
+
+	@source_type.setter
+	def source_type(self, value):
+		self._source_type = value
+
+	@property
+	def index(self):
+		""" """
+		return self._index
+
+	@index.setter
+	def index(self, value):
+		self._index = value
+
+	@property
+	def storage(self):
+		""" """
+		return self._storage
+
+	@storage.setter
+	def storage(self, value):
+		self._storage = value
+
+	@property
+	def identifier(self):
+		""" """
+		return self._identifier
+
+	@identifier.setter
+	def identifier(self, value):
+		self._identifier = value
+
+	@property
+	def name(self):
+		""" """
+		return self._name
+
+	@name.setter
+	def name(self, value):
+		self._name = value
+
+	@property
+	def type(self):
+		""" """
+		return self._type
+
+	@type.setter
+	def type(self, value):
+		self._type = value
 
 	@classmethod
 	def from_identifier(self, func, identifier, name = None, var_type = None):
@@ -303,10 +640,10 @@ class Variable(object):
 
 class ConstantReference(object):
 	def __init__(self, val, size, ptr, intermediate):
-		self.value = val
-		self.size = size
-		self.pointer = ptr
-		self.intermediate = intermediate
+		self._value = val
+		self._size = size
+		self._pointer = ptr
+		self._intermediate = intermediate
 
 	def __repr__(self):
 		if self.pointer:
@@ -315,6 +652,43 @@ class ConstantReference(object):
 			return "<constant %#x>" % self.value
 		return "<constant %#x size %d>" % (self.value, self.size)
 
+	@property
+	def value(self):
+		""" """
+		return self._value
+
+	@value.setter
+	def value(self, value):
+		self._value = value
+
+	@property
+	def size(self):
+		""" """
+		return self._size
+
+	@size.setter
+	def size(self, value):
+		self._size = value
+
+	@property
+	def pointer(self):
+		""" """
+		return self._pointer
+
+	@pointer.setter
+	def pointer(self, value):
+		self._pointer = value
+
+	@property
+	def intermediate(self):
+		""" """
+		return self._intermediate
+
+	@intermediate.setter
+	def intermediate(self, value):
+		self._intermediate = value
+
+
 
 class IndirectBranchInfo(object):
 	def __init__(self, source_arch, source_addr, dest_arch, dest_addr, auto_defined):
diff --git a/python/highlight.py b/python/highlight.py
index 2949e6d9..344468ef 100644
--- a/python/highlight.py
+++ b/python/highlight.py
@@ -27,25 +27,97 @@ from binaryninja.enums import HighlightColorStyle, HighlightStandardColor
 class HighlightColor(object):
 	def __init__(self, color = None, mix_color = None, mix = None, red = None, green = None, blue = None, alpha = 255):
 		if (red is not None) and (green is not None) and (blue is not None):
-			self.style = HighlightColorStyle.CustomHighlightColor
-			self.red = red
-			self.green = green
-			self.blue = blue
+			self._style = HighlightColorStyle.CustomHighlightColor
+			self._red = red
+			self._green = green
+			self._blue = blue
 		elif (mix_color is not None) and (mix is not None):
-			self.style = HighlightColorStyle.MixedHighlightColor
+			self._style = HighlightColorStyle.MixedHighlightColor
 			if color is None:
-				self.color = HighlightStandardColor.NoHighlightColor
+				self._color = HighlightStandardColor.NoHighlightColor
 			else:
-				self.color = color
-			self.mix_color = mix_color
-			self.mix = mix
+				self._color = color
+			self._mix_color = mix_color
+			self._mix = mix
 		else:
 			self.style = HighlightColorStyle.StandardHighlightColor
 			if color is None:
-				self.color = HighlightStandardColor.NoHighlightColor
+				self._color = HighlightStandardColor.NoHighlightColor
 			else:
-				self.color = color
-		self.alpha = alpha
+				self._color = color
+		self._alpha = alpha
+
+	@property
+	def alpha(self):
+		""" """
+		return self._alpha
+
+	@alpha.setter
+	def alpha(self, value):
+		self._alpha = value
+
+	@property
+	def mix(self):
+		""" """
+		return self._mix
+
+	@mix.setter
+	def mix(self, value):
+		self._mix = value
+
+	@property
+	def mix_color(self):
+		""" """
+		return self._mix_color
+
+	@mix_color.setter
+	def mix_color(self, value):
+		self._mix_color = value
+
+	@property
+	def color(self):
+		""" """
+		return self._color
+
+	@color.setter
+	def color(self, value):
+		self._color = value
+
+	@property
+	def style(self):
+		""" """
+		return self._style
+
+	@style.setter
+	def style(self, value):
+		self._style = value
+
+	@property
+	def green(self):
+		""" """
+		return self._green
+
+	@green.setter
+	def green(self, value):
+		self._green = value
+
+	@property
+	def red(self):
+		""" """
+		return self._red
+
+	@red.setter
+	def red(self, value):
+		self._red = value
+
+	@property
+	def blue(self):
+		""" """
+		return self._blue
+
+	@blue.setter
+	def blue(self, value):
+		self._blue = value
 
 	def _standard_color_to_str(self, color):
 		if color == HighlightStandardColor.NoHighlightColor: