Beginner question: module organisation

[Mail.To.Nathaniel]

Hello :)

I am new to python and I don't have much expirience in object-oriented
technologies neither.

The problem is the following: I have to create a simple python
template script that will always follow the same algorithm, let's say:
- read a mesh
- transform the mesh (let's say, refine)

The last step should be a kind of a black box:
- the same input data format
- some algorithme inside
- the same output data format

A number of different refine methods should be implemented. The end-
user must be able to write easily a new method and call it from the
base script without any major change.

Something like this would be a solution (no classes created, no OO
programming):
- a module defining REFINE1(mesh), REFINE2(mesh), ...
- in the script:
from MODULE import REFINE2 as REFINE
REFINE(mesh)

Is it a proper solution for this kind of problem? How would you
implement this kind of task?

[Nick Vatamaniuc]

On May 14, 9:09 am, [e-mail] wrote:

Hello :)

I am new to python and I don't have much expirience in object-oriented
technologies neither.

The problem is the following: I have to create a simple python
template script that will always follow the same algorithm, let's say:
- read a mesh
- transform the mesh (let's say, refine)

The last step should be a kind of a black box:
- the same input data format
- some algorithme inside
- the same output data format

A number of different refine methods should be implemented. The end-
user must be able to write easily a new method and call it from the
base script without any major change.

Something like this would be a solution (no classes created, no OO
programming):
- a module defining REFINE1(mesh), REFINE2(mesh), ...
- in the script:
from MODULE import REFINE2 as REFINE
REFINE(mesh)

Is it a proper solution for this kind of problem? How would you
implement this kind of task?

Why not OO? This is a good problem for OO. For example: there is a
base class (BaseMesh) that will take care of loading your
mesh,provide a generic (possibly empty) refine() method, output the
mesh and have a bunch of utility functions. You can put that in a
module like meshing.py.

Then the user will do:
--------------------------------------------
from meshing import BaseMesh
class UsersMesh(BaseMesh):
def __init__(self,...):
BaseMesh.__init__(self,...)
....etc. initializer...
def refine(self,...):
...user's refine method would go here...
--------------------------------------------------

So for each different refine() method the user can derive a new class
from BaseMesh and overload the refine(...) method.

Hope that helps,
-Nick Vatamaniuc

[Rainer Grimm]

Ma***************@gmail.com wrote:

Hello :)

I am new to python and I don't have much expirience in object-oriented
technologies neither.

The problem is the following: I have to create a simple python
template script that will always follow the same algorithm, let's say:
- read a mesh
- transform the mesh (let's say, refine)

The last step should be a kind of a black box:
- the same input data format
- some algorithme inside
- the same output data format

A number of different refine methods should be implemented. The end-
user must be able to write easily a new method and call it from the
base script without any major change.

Something like this would be a solution (no classes created, no OO
programming):
- a module defining REFINE1(mesh), REFINE2(mesh), ...
- in the script:
from MODULE import REFINE2 as REFINE
REFINE(mesh)

Is it a proper solution for this kind of problem? How would you
implement this kind of task?

Hello.

Have a look at the classical GangOfFour design pattern book. You can
especially with the template methode design the processing of your data.
The strategy pattern will help you to vary the algroithm in your processing.

To be concret, in your base class you define the processing of the data.
There are two distinct methods to do it.
delegate the variation of the algorithmns to other objects =strategy
pattern
override the steps of the processing in subclasses =template method

Regards,
Rainer
--
_________________________creating IT solutions
Rainer Grimm
scVENUS Schulungsleiter science + computing ag
phone [phone] Hagellocher Weg 73
fax [phone] D-72070 Tuebingen, Germany
r.*****@science-computing.de www.science-computing.de

[7stud]

On May 14, 7:09 am, [e-mail] wrote:

Hello :)

I am new to python and I don't have much expirience in object-oriented
technologies neither.

The problem is the following: I have to create a simple python
template script that will always follow the same algorithm, let's say:
- read a mesh
- transform the mesh (let's say, refine)

The last step should be a kind of a black box:
- the same input data format
- some algorithme inside
- the same output data format

A number of different refine methods should be implemented. The end-
user must be able to write easily a new method and call it from the
base script without any major change.

Something like this would be a solution (no classes created, no OO
programming):
- a module defining REFINE1(mesh), REFINE2(mesh), ...
- in the script:
from MODULE import REFINE2 as REFINE
REFINE(mesh)

Is it a proper solution for this kind of problem? How would you
implement this kind of task?

How about this:

refineModule.py:
---------------
def refine(userfunc, mesh):
#process mesh
func(mesh)

aprogram.py:
------------
import refineModule

def myRefine(mesh):
print mesh

refineModule.refine(myRefine, "hello world")

[7stud]

On May 19, 10:45 am, 7stud <[e-mail]:

>
refineModule.py:
---------------
def refine(userfunc, mesh):
#process mesh
func(mesh)

The last line should be:

userfunc(mesh)

[Mail.To.Nathaniel]

Thank you for all your help!

I'll study the proposals to chose the one I prefer or to create
something new :) Anyway, this is a perfect start-up for me.

Nathaniel.