Class Modules, and Passing Variables: Seeking Advice

[Robo_Pi]

Class Modules, and Passing Variables: Seeking Advice

Introduction
Hello, this is my first post and I'm just learning Python so please forgive my ignorance. I'm just starting a huge project that will quickly become quite complex. For this reason I would like to get it started off on a solid foundation. The following program runs and does what I expect. However, I pieced this together using newly discovered ideas so there may be far better ways to do this. I'm seeking suggestions for how I might make make the code better. SPECIFICALLY - in the area of creating Class Modules and Passing Variables between them. I'm aware that I have not yet programed against file reading errors. I plan on doing that using try-exception, but I left that out for now for simplicity sake. Right now I'm just working on creating totally independent classes that can pass variables back to the original main program.

Short Explanation of the Project
I'm building a robot that uses a Raspberry Pi for a brain. I want to be able to communicate with this Raspberry Pi via WiFi using my Notebook computer. I have decided to do this by simply passing a small text file back and forth between them. The robot will only need a few English word commands it will be able to carry out the tasks on its own from there. So the following program is extremely simple. It just reads the text file and converts the content into a Python List.

My Immediate Goal for Now
Below there are two programs or "classes". The first is Main() the second is Aylsha_Read(). Main() will eventually become an infinite looping program that will be the robot's continually conscious brain. Main() will eventually be calling many other classes. Alysha_Read() is simply the first class I've written. I want to keep all classes that are not required in Main() as totally separate files in separate directories. This is why Alysha_Read is in a separate namespace (or folder) also called Alysha_Read. I don't want Alysha_Read() to be a method inside Main(). Keeping all my sub-classes in separate files in separate directors will become extremely important as this project grows. I can imagine this project become extremely huge as time goes on.

So for this reason I would like to get this system down pat at the very beginning of the project.

Here's my current Source File Directory Hierarchy.
(NOTE: This places Alysha_Read() in the Alysha_Read namespace)

Alysha <---- Project directory.
--> Alysha.py <---- Main() Python program.
--> Alysha_Read <---- Directory within the Alysha directory.
-------> __init__.py <---- *IMPORTANT empty file required by Python.
-------> Alysha_Read.py <---- Alysha_Read() class.

*note: every sub-directory must contain an empty __init__.py file in order for Python to recognize the directory as a valid Namespace. So if you should try to duplicate this system don't forget to create this empty file or it won't work.

And now let's take a look at the code I've written thus far.

Alysha.py

All this code does is pass an empty list named "Tasks" to Alysha_Read() using Alysha_Read(Tasks).
Then it obtains the actual task list using Tasks = Alysha_Read.Task_Commands.
Finally it prints out the newly acquire Task list.
A very simple program to be sure.
However this does require the directory hierarchy described previously in order for the import statement to work correctly.

""" 
Robot Communications Program. 
"""

# Need to import the class Alysha_Read()
from Alysha_Read.Alysha_Read import *

def main():
	"""
	This is Alysha's Main Module
	"""

	# Need to create the following string array or list:
	Tasks=[]
	# Call Alysha_Read Class to read the Commands.txt file
	# And pass to it the empty list named "Tasks"
	Alysha_Read(Tasks)
	# Get the Task_Commands after the return,...
	# Update the previous empty Task list with the new list.
	Tasks = Alysha_Read.Task_Commands
	
	# --- The following are just programming tools. 
	print Tasks
	# help(Alysha_Read)
	# help(main)
	
	# Only need the following on SharpDevelop to keep, 
	# the terminal window open to read it
	a = int(raw_input("Press enter:"))
	
	# This program is done for now but will eventually,...
	# loop eternally as this will become Alysha's main brain.
	return 0

if __name__ == '__main__':
	main()

Next is the Alysha_Read() Class.

Alysha_Read.py

class Alysha_Read():
	""" 
	---- Alysha_Read:Alysha_Read class to read the Commands.txt ----
	This program reads the text file in the Robo_Pass folder on the Raspberry Pi
	It converts that text file into a Python List and then passes the list
	back to the program that called this class.  
	The passing list is called	"Task_Commands"
	This is done to place the commands in a List Variable. (or String Array),
	that can then be accessed via indexes. Task_Commands[i]	
	This Class must be called using Alysha_Read(list),
	where list should be an empty list. 
	Then upon return you can obtain the Task_Commands by using:
	Commands = Alysha_Read.Task_Commands
	"""
	
	### 	--- Addresses for Commands.txt file -------
    # Overseer directory
	File_Path = 'C:/100_Robo_pass/Commands.txt'

	### File_Path = /home/pi/Robo_pass/Commands.txt'
	
	
	# ---------- Begin Reading Commands.txt Routine --------------
	
	# Create a string array or list named Raw_Task_Commands
	# This reads the entire Command File
	# Required to be able to count how many commands there are.
	Raw_Task_Commands = []
	# Create a new string array to for the individual clean commands.
	Task_Commands = []
	# Read the Commands.txt file on HP-Elite using the Ptyhon open function
	# Create the file-reading object named "Stream_Reader_1".
	# ---
	# --- B E W A R E ! ! ! ---- use the correct filename for each robot.
	# ---
	Stream_Reader_1 = open(HP_Elite_1, 'r')
	# Read in the entire file into "Raw_Task_Commands" array.
	Raw_Task_Commands = Stream_Reader_1.readlines()
	# Break out the commands, get the count, and clean them up.
	# (note) len(Raw_Task_Commands) is the count. 
	for i in range(0,len(Raw_Task_Commands)):
		# Isolate the first command.
		raw_Command_String = Raw_Task_Commands[i]
		# Strip off the carriage returns and line feed.
		raw_Command_String = raw_Command_String.strip()
		# Append this into the new clean Command array.
		Task_Commands.append(raw_Command_String)
		# won't need the following print on the final version.
		# ---- For Debug Only ----	
		print raw_Command_String
	# Close the file!	
	Stream_Reader_1.close
	
	def __init__(self, Task_Commands):
		""" 
		This is my initiation function in Alysha_Read
		Task_Commands is assigned to this Class
		as a passable list array using this __init__ function
		
		"""

		

[Robo_Pi]

Sorry but the above post got posted by accident before it was finished. And now I can't edit it!!!

---

Sorry about the mistaken early post. I was interrupted and it got posted before I was done. The following is how the original OP was supposed to end.


Next is the Alysha_Read() Class.

Alysha_Read.py

This class reads a text file named "Commands.txt" located at the address contained in "File_Path".
It then converts the content of that file into a Python List and returns the list to the calling program.

class Alysha_Read():
	""" 
	---- Alysha_Read:Alysha_Read class to read the Commands.txt ----
	This program reads the text file in the Robo_Pass folder on the Raspberry Pi
	It converts that text file into a Python List and then passes the list
	back to the program that called this class.  
	The passing list is called	"Task_Commands"
	This is done to place the commands in a List Variable. (or String Array),
	that can then be accessed via indexes. Task_Commands[i]	
	This Class must be called using Alysha_Read(list),
	where list should be an empty list. 
	Then upon return you can obtain the Task_Commands by using:
	Commands = Alysha_Read.Task_Commands
	"""
	
	### 	--- Addresses for Commands.txt file -------
    # Overseer directory
	File_Path = 'C:/100_Robo_pass/Commands.txt'
    # Raspberry Pi directory
	### File_Path = /home/pi/Robo_pass/Commands.txt'
	
	
	# ---------- Begin Reading Commands.txt Routine --------------
	
	# Create a string array or list named Raw_Task_Commands
	# This reads the entire Command File
	# Required to be able to count how many commands there are.
	Raw_Task_Commands = []
	# Create a new string array to for the individual clean commands.
	Task_Commands = []
	# Read the Commands.txt file on HP-Elite using the Ptyhon open function
	# Create the file-reading object named "Stream_Reader_1".
	# ---
	# --- B E W A R E ! ! ! ---- use the correct filename for each robot.
	# ---
	Stream_Reader_1 = open(File_Path, 'r')
	# Read in the entire file into "Raw_Task_Commands" array.
	Raw_Task_Commands = Stream_Reader_1.readlines()
	# Break out the commands, get the count, and clean them up.
	# (note) len(Raw_Task_Commands) is the count. 
	for i in range(0,len(Raw_Task_Commands)):
		# Isolate the first command.
		raw_Command_String = Raw_Task_Commands[i]
		# Strip off the carriage returns and line feed.
		raw_Command_String = raw_Command_String.strip()
		# Append this into the new clean Command array.
		Task_Commands.append(raw_Command_String)
		# won't need the following print on the final version.
		# ---- For Debug Only ----	
		print raw_Command_String
	# Close the file!	
	Stream_Reader_1.close
	
	def __init__(self, Task_Commands):
		""" 
		This is my initiation function in Alysha_Read
		Task_Commands is assigned to this Class
		as a passable list array using this __init__ function
		
		"""

		

The Command.txt File contains the following information:

Task 1
Task 2
Task 3
Task 4
Task 5
Task 6
Task 7
Task 8
Task 9
Task 10

The program returns the following List as an output:

Output:
['Task 1','Task 2','Task 3','Task 4','Task 5','Task 6','Task 7','Task 8','Task 9','Task 10']

Questions

This program works as expected. My only question is to ask for any suggestions of advice on how I might improve on this software design. Specially in terms of setting up classes as independent files, and in terms of passing variables between these classes. Have I done things correctly? I'm just starting out programming in Python so I'll be surprised if I'm doing things correctly.

Any suggestions for improvements are welcome.

Thanks for reading.

[Robo_Pi]

UPDATE:

I just restructured the entire program just figuring things out on my own. I'm much happier with the the following classes and methods. So I thought I'd post what I've done just in case anyone is interested.

My Original Folly
I was originally using the Class itself as a Method. And that certainly worked. But it's not what I wanted. I actually wanted an entire class of methods. So that's what I have now. And I'll try to explain what I've changed from the original plan. This may be helpful for someone else who might want to do something similar. This example if quite small so it should be easy to understand.

The Directory Structure for the Source Code.

I've changed my previous directory structure to the following:

Alysha <---- Project directory.
--> Alysha.py <---- Main() Python program.
--> Alysha_Pass <---- Directory within the Alysha directory. (Changed the NAME of this directory)
-------> __init__.py <---- *IMPORTANT empty file required by Python.
-------> Alysha_Pass.py <---- Alysha_Pass() class. (Changed the the NAME of the actual Class)

And now for how the code works differently:

Alysha.py

Now I call the method Alysha_Read() that resides within the Alysha_Pass Class.
Now everything is done on line line of code:
Tasks = Alysha_Pass().Alysha_Read()

But far more importantly, I can have many methods contained within the Alysha_Pass Class.

(see the coding for Alysha_Pass.py)

""" 
Robot Communications Program. 
"""

# Need to import the class Alysha_Pass()
from Alysha_Pass.Alysha_Pass import *

def main():
	"""
	This is Alysha's Main Module
	"""
	
	# Call Alysha_Read Class to read the Commands.txt file
	# And pass to it a new list named "Tasks"
	Tasks = Alysha_Pass().Alysha_Read() 
	
	# --- The following are just programming tools.
	print "\nThe resulting Task List\n"
	print Tasks	

	# --- Call to Alysha_Write() just to see it working.
	Alysha_Pass().Alysha_Write("Dummy Message from Alysha_Write")

# --- Progamming Tools -----
# 	help(Alysha_Write)
#	help(Alysha_Read)
#	help(main)
	
	# Only need the following on SharpDevelop to keep, 
	# the terminal window open to read it
	a = int(raw_input("Press enter:"))
	
	# This program is done for now but will eventually,
	# loop eternally as this will become Alysha's main brain.
	return 0

if __name__ == '__main__':
	main()

Alysha_Pass.py

Notice in this new class I no longer assign a variable to the entire class using the __init__() method.

Instead, I have the method Alysha_Read() simply return the list using its return function.
There is no need to pass anything to the Alysha_Read() method.

Also, I'm able to include a method called Alysha_Write() that will require a message be passed to it. This method will eventually write to a different file to serve as the reply from the Raspberry Pi back to the Notebook computer.

This is what I wanted and apparently this is the correct way to do this. Far better than what I originally started out trying to do.

I've included a very small example of passing a message to Alysha_Write() to to have it show that it's working. Eventually this method will actually write to a file.

The nice thing about using the class Alysha_Pass() in this way is that I can add as many methods as I would like that have to do with passing information between this robot and any other devices or robots. It's nice to have all these classes separate and independent. And this was my main goal.

When all is said and done I'm sure I'll have lots of Classes containing many methods each. And now I know how to do this.

class Alysha_Pass:
	
	def Alysha_Read(self):
		""" 
		---- Alysha_Pass().Alysha_Read(self) Method to read the Commands.txt ----
		This program reads the text file in the Robo_Pass folder on the Raspberry Pi
		It converts that text file into a Python List and then passes the list
		back to the program that called this class.  
		The passing list is called	"Task_Commands"
		This is done to place the commands in a List Variable. (or String Array),
		that can then be accessed via indexes. Task_Commands[i]	
		This Class must be called using Alysha_Read(list),
		where list should be an empty list. 
		Then upon return you can obtain the Task_Commands by using:
		Commands = Alysha_Read.Task_Commands
		"""
			
		### 	--- Addresses for Files -------
		# --- File path on the Robot Overseer computer.
		File_Path = 'C:/100_Robo_pass/Commands.txt'
		# --- File path on Raspberry Pi
		### File_Path = /home/pi/Robo_pass/Commands.txt'
				
		# ---------- Begin Reading Commands.txt Routine --------------
		
		# Create a string array or list named Raw_Task_Commands
		# This reads the entire Command File
		# Required to be able to count how many commands there are.
		Raw_Task_Commands = []
		# Create a new string array  for the individual clean commands.
		Task_Commands = []
		# Read the Commands.txt file using the Ptyhon "open" function
		# Create a file-reading object named "Stream_Reader_1".
		# ---
		# --- B E W A R E ! ! ! ---- use the correct filename for each robot.
		# ---
		Stream_Reader_1 = open(File_Path, 'r')
		# Read in the entire file into "Raw_Task_Commands" array.
		Raw_Task_Commands = Stream_Reader_1.readlines()
		# The following print os for debug only.
		print "Original File Lines\n"	
		# Break out the commands, get the count, and clean them up.
		# (note) len(Raw_Task_Commands) is the count.
		for i in range(0,len(Raw_Task_Commands)):
			# Isolate the first command.
			raw_Command_String = Raw_Task_Commands[i]
			# Strip off the carriage returns and line feed.
			raw_Command_String = raw_Command_String.strip()
			# Append this into the new clean Command array.
			Task_Commands.append(raw_Command_String)
			# won't need the following print on the final version.
			# ---- For Debug Only ----	
			print raw_Command_String
		# Close the file!	
		Stream_Reader_1.close
		# Return the entire clean List of tasks. 
		return (Task_Commands)
		
	def Alysha_Write(self, Message):
		"""
		
		---- Alysha_Pass().Alysha_Write(self, Message) Method ----
		This method will eventually write to a message file to be,...
		returned to the Overseer computer.
		"""		
		print "\n" , Message , "\n"
	
	
	def __init__(self):
		pass

Summary

I made a lot of progress on this on my own in just one day! I'm feeling good about this. But I'm always open to any constructive comments or suggestions too. But I'm really happy with what I've done thus far.

Keep in mind that if you want to create a similar system, you need to make sure you include a empty __init__.py file in the directory of the classes. Otherwise Python will give you an error when you try to import from that directory.

Also for my example above, you need a Commands.txt file available to read. I've already described what that file contained in a previous post, and that hasn't changed.

This program takes the content of that text file and converts it to a nice clean Python list so I can access the commands or tasks via indexes one at a time. That was the goal of this initial project.

But a far bigger goal was to learn how to set up classes and methods in their own directories and to be able to pass variables between them. I think I have that all figured out now. So this was a major learning experience for me.

I'm just learning Python. This was my first program after "Hello World!".

[Larz60+]

Narrow your request down, and ask questions one at a time.
there are so many posts every day, and only a handful of moderators to answer each question.
Such a large post will probably go unanswered because it requires too much time to absorb the
gist of what is being looked for.
So please try to simplify.
Thanks

[Robo_Pi]

Sorry. I was trying to give an overview of what I'm trying to do. I can offer a very simplified version for the purpose of asking my questions.

Simplified Version:

I am creating a separate class of methods from my main program and I just wanted to ask if I'm doing this correctly.

Here's my main program saved as

Alysha.py

from Alysha_Pass.Alysha_Pass import *

def main():

	Tasks = Alysha_Pass().Alysha_Read() 
	print Tasks	
	
	Alysha_Pass().Alysha_Write("Dummy Message")

	return 0
if __name__ == '__main__':
	main()

Here's the new class I've just created that contains two methods:

Alysha_Pass.py

class Alysha_Pass:
	
	def Alysha_Read(self):
		Tasks = ['Task 1','Task 2','Task 3','Task 4','Task 5']
		return (Tasks)
		
	def Alysha_Write(self, Message):
		print "\n" , Message , "\n"
		
	def __init__(self):
		pass

All this code works just fine and produces the expected output below:

Output:
['Task 1', 'Task 2', 'Task 3', 'Task 4', 'Task 5']

Dummy Message

My Question

Is the above code a valid way to do this? Mainly in terms of creating an independent class that is separate from the main program, and in terms of passing the variables back and forth?

The reason I'm asking is because I just pieced this together on the fly by trial and error. I'm just learning Python and I want to be sure that I'm getting off on a solid foundation. I'll be writing many classes and methods using a similar structure. So I just want to be sure I'm getting off on the right foot.

Thanks.

[Larz60+]

This is the way I would do it:

class Alysha_Pass:
    def __init__(self):
        pass

    def Alysha_Read(self):
        Tasks = ['Task 1', 'Task 2', 'Task 3', 'Task 4', 'Task 5']
        return (Tasks)

    def Alysha_Write(self, Message):
        print('\n{}\n'.format(Message))

The __init__ typically is placed at the top

import Alysha_Pass


def main():
    ap = Alysha_Pass.Alysha_Pass()
    Tasks = ap.Alysha_Read()
    print(Tasks)

    ap.Alysha_Write("Dummy Message")

    return 0


if __name__ == '__main__':
    main()

And still works:

Output:
['Task 1', 'Task 2', 'Task 3', 'Task 4', 'Task 5']

Dummy Message

[buran]

I agree with Larz. It's more correct/intuitive to have a class Alysha with multiple methods. Think of class as objects. Reading is "activity", i.e. it's intuitive to have it as method of an object (class), different properties of an object (like color or list of commands), well have them as property of the class. In certain cases it may be convenient for you to have an abstract object like Reader, but this is not the case here.

Also, I strongly advise you to read PEP 8 and follow it, because your current code does not comply with it and is hard to follow and will be difficult for other people to contribute in the future if it becomes large project.

[Gribouillis]

In addition to buran's suggestion of using pep8 especially the part on class names and method names, I see three points that could be improved

• Use python 3 instead of python 2 since the latter is reaching the end of its life cycle.
  
• I would not hard-code the filename 'C:/100_Robo_pass/Commands.txt'. It would be better in a configuration file together with other global constants.
  
• It is not necessary to use Alysha_ prefix for every class and every function.
  

[Robo_Pi]

Also, I strongly advise you to read PEP 8 and follow it, because your current code does not comply with it and is hard to follow and will be difficult for other people to contribute in the future if it becomes large project.

Ok PEP 8 will be very helpful. I'm self-learning so I need to know what to read. I'll go over my project and apply these style conventions. I love to be consistent so all I needed was a guideline on how to be properly consistent. I'll study PEP 8 and employ those guidelines. Thanks.

---

• Use python 3 instead of python 2 since the latter is reaching the end of its life cycle.
  

This is going to be a major undertaking for me. I'm using 9 different computers to write this project on. They currently all have python 2.7 installed. So I'll need to upgrade all of them to python 3. 3 of these computers us the SharpDevelop IDE and the I've downloaded the lastest version of those. They all contain Python 2.7 and I'm not sure how to upgrade them to use Python 3. Would it be as simple as installing Python 3 on Windows? As far as I can tell Windows doesn't even have Python installed at all. The SharpDevelop IDE appears to have come with Python 2.7 built into it as an add-on.

I'll need to look into upgrading SharpDevelop to Python 3. The other 6 computers are all running Linux so it will be easy to upgrade them to Python 3.

I just wonder if it's worth all that work? This entire project is just for a home robot. I'm not planning on doing anything commercial with this.

All 9 of my computers have python 2.7 on them. Nary a one had Python 3.

• I would not hard-code the filename 'C:/100_Robo_pass/Commands.txt'. It would be better in a configuration file together with other global constants.
  

I don't like hard-coding the filename either. I'm just not aware of how to implement a configuration file as you have suggested, but that certainly sounds like something I would like to learn how to do.

• It is not necessary to use Alysha_ prefix for every class and every function.
  

Using the alysha prefix is important for me because I'll be having an almost identical project going along at the same time. So by using these prefixes for all my directories and file names I'll be able to tell at a glance which project they belong to.

I could drop the underscore though and just use alyshapass.AlyshaPass() using the PEP 8 style.

I see now that I can name the methods just Read() and Write() since there won't be any files created for those methods. Only the class name will have a *.py file.

I'm just learning how to do this. But in addition to my robot project I'm simultaneously writing a Garden Train controller project. These both use Raspberry Pi communicating with a Notebook computer. But they will be different enough in many ways to warrant keeping them as separate projects.

So I'll have a very similar project with a main() named Garden.py and that will have a gardenpass.GardenPass() class as well. Very similar, but with enough important differences to warrant a separate project.

So using this naming convention will be important for my own sanity.

[Robo_Pi]

ok here's my upgrade to PEP 8 style conventions:

Changes that I've made:

1. Changed namespace folder to lowercase. alysha_pass. (Using underscore here because of lowercase)
   
2. Removed underscore from the class name AlyshaPass()
   
3. Removed the Alysha_ prefix from the read() and write() methods and wrote them using all lowercase.
   

Alysha.Py

from alysha_pass.AlyshaPass import *

def main():

	Tasks = AlyshaPass().read() 
	print Tasks	
	
	Alysha_Pass().write("Dummy Message")

	return 0
if __name__ == '__main__':
	main()

AlyshaPass.Py

class AlyshaPass():
	def __init__(self):
		pass

	def read(self):
		Tasks = ['Task 1','Task 2','Task 3','Task 4','Task 5']
		return (Tasks)
		
	def write(self, Message):
		print "\n" , Message , "\n"	

Output:
['Task 1', 'Task 2', 'Task 3', 'Task 4', 'Task 5']

Dummy Message

Any other great suggestions?

I'll look into upgrading to Python 3, but I'm not going to do that right away.

I would also like to learn more about how to create and implement a configuration file that Gribouillis had suggested for the file path names and global variables. That sounds interesting I don't like having to hard-code file paths so if there's better way to do that I'm all eyes. Can you point to any instructions on how to do that?

Thanks for all the constructive mentoring thus far. This is what I came here for.

---

Further Housecleaning via PEP 8 style:

I was concentrating so much on the class and methods formatting that I forgot about the variable names conventions.

So now I realize that Tasks should be tasks in both Alysha.py and AlyshaPass.py and the variable "message" in the write method also should be all lowercase.

So,... here's the latest update:

Alysha.py

from alysha_pass.AlyshaPass import *
 
def main():
 
    tasks = AlyshaPass().read() 
    print tasks 
     
    Alysha_Pass().write("Dummy Message")
 
    return 0
if __name__ == '__main__':
    main()

AlyshaPass.py

class AlyshaPass():
    def __init__(self):
        pass
 
    def read(self):
        tasks = ['Task 1','Task 2','Task 3','Task 4','Task 5']
        return (tasks)
         
    def write(self, message):
        print "\n" , message , "\n" 

I'm learning one step at a time.