Pythonic way of rewrite Java code in Python

Question

I have to write a library in python which was written in Java before. Coming from a Java background python is giving me a little difficult time. I am stuck with choosing the right pythonic way of doing something..

So, My java code is something like:

import java.util.Collection;

public abstract class MyEnumBaseClass
{
    protected int    value;
    protected String description = null;

    protected MyEnumBaseClass(int iValue, String iDescription)
    {
        value = iValue;
        description = iDescription;
    }

    public int getValue()
    {
        return value;
    }

    public String getDescription()
    {
        return description;
    }

    protected static MyEnumBaseClass getEnum(Collection<MyEnumBaseClass> iter, int value)
    {
        for (MyEnumBaseClass enumObj : iter)
        {
            if (enumObj.getValue() == value)
            {
                return enumObj;
            }
        }
        return null;
    }
}



import java.util.ArrayList;
import java.util.Collection;

public class MyEnumClass extends MyEnumBaseClass
{
    private final static Collection<MyEnumBaseClass> enumList   = new ArrayList<MyEnumBaseClass>();

    public final static int                          ERROR1     = 1;
    public final static int                          ERROR2     = 2;
    public final static int                          ERROR3     = 3;
    public final static int                          ERROR4     = 4;

    public final static MyEnumClass                  ErrorEnum1 = new MyEnumClass(ERROR1, "ERROR1");
    public final static MyEnumClass                  ErrorEnum2 = new MyEnumClass(ERROR2, "ERROR1");
    public final static MyEnumClass                  ErrorEnum3 = new MyEnumClass(ERROR3, "ERROR1");
    public final static MyEnumClass                  ErrorEnum4 = new MyEnumClass(ERROR4, "ERROR1");

    protected MyEnumClass(int iValue, String iDescription)
    {
        super(iValue, iDescription);
    }

    public static int getCount()
    {
        return enumList.size();
    }

    public static Collection<MyEnumBaseClass> getList()
    {
        return enumList;
    }

    public static MyEnumBaseClass getEnum(int value)
    {
        return getEnum(enumList, value);
    }
}

I want to write something this in python. I understand both languages are totally different. I don't want to replicate exact code but I want to write something in python which give me the functionality Java code is giving.

So I came up with something like:

# MODULE MYENUMBASECLASS:::

class MyEnumBaseClass(object):

    def __init__(self, iValue, iDescription, ui = None):
        self._value = iValue
        self._description = iDescription

    def getValue(self):
        return self._value

    def getDescription(self):
        return self._description

    @classmethod
    def getEnum(cls, value, itr):
        for enumObj in itr:
            if enumObj.getValue() == value:
                return enumObj
        return None


# MODULE: ENUMS:::
from MyEnumBaseClass import MyEnumBaseClass

__all__ = ["MyEnumClassConstants", "MyEnumClass", "MyEnums"]
_enumList = []

class MyEnumClassConstants(object):
    ERROR1 = 1
    ERROR2 = 2
    ERROR3 = 3
    ERROR4 = 4

class MyEnumClass(MyEnumBaseClass):
    def __init__(self, v, d, ui):
        global _enumList
        super(MyEnumClass, self).__init__(v, d, ui)
        _enumList.append(self)

    @staticmethod
    def getCount():
        return len(_enumList)

    @staticmethod
    def getList():
        return _enumList

    @classmethod
    def getEmum(cls, value, itr = None):
        return super(MyEnumClass, cls).getEnum(value, _enumList)


class MyEnums(object):
    ErrorEnum1 = MyEnumClass(MyEnumClassConstants.ERROR1, "ERROR1");
    ErrorEnum2 = MyEnumClass(MyEnumClassConstants.ERROR2, "ERROR2");
    ErrorEnum3 = MyEnumClass(MyEnumClassConstants.ERROR3, "ERROR3");
    ErrorEnum4 = MyEnumClass(MyEnumClassConstants.ERROR4, "ERROR4");

I Want to know:

Is it the correct pythonic way of doing it?
I wanted to move the ErrorEnum1,2,3,4 and constants out of the MyEnums class as a module variable. But that way I will have a long list in my all variable. also I have a risk of variable name clash when I will import Enums module in other module (some other Enums2 module may also have ErrorEnum1,2,3.. But that is not a big problem. We can always use Enums.ErrorEnum1 and Enums2.ErrorEnum1). Am I thinking right?
I know this is not perfect (my first python code ever). So I invite you guys for giving me ideas.

Thanks

Completely off-topic, but is there a reason why you didn’t use Java’s enum types? — poke
– poke, Commented Jun 26, 2012 at 20:57
I don't have any explanation for that. Because it was already like this when I got this work of creating the python API. This was being used in SOAP messages. So, as far as I understand, the java code I pasted gives the advantage of having error code and description. While the Java Enums don't. Also there is other code which I have removed, because that doesn't matter for the question I am asking here. — Ashutosh
– Ashutosh, Commented Jun 26, 2012 at 21:09
Enums in Java are actually just special classes, so you can attach nearly everything to it you would be able to for a normal class. Off-topic, as this question is about the Python code, not the Java code, but I was just wondering… ;) — poke
– poke, Commented Jun 26, 2012 at 21:13
@brandizzi I was expecting this reply for such a long post..Nice link btw. :) — Ashutosh
– Ashutosh, Commented Jun 26, 2012 at 21:37

brandizzi · Accepted Answer · 2012-06-27 02:19:04Z

Well, I suppose you are aware that your code is less than optimal and certainly is not the way to go. Another problem is that we cannot say how you can "write something in python which give me the functionality Java code is giving" because we do not know exactly what you are trying to do. That said, there is a lot of obvious Java bias in your code that one can remove without any problem:

First, why to have a MyEnumBaseClass and a MyEnumClass? You can have only one. It will reduce the number of classes and the number of modules. Even if you want to extend your enum, you will see that, after simplifying your code, your MyEnumClass will be so simple you can extend it without problems.
Now, please, no getters and setters. You have no reason to use them, since you have properties. If your properties will only get and set values, do not use properties anyway:
```
class MyEnumClass(object):
    def __init__(self, value, description, ui = None):
        self.value = value
        self.description = description
```
It is really ugly to create a class just to hold constant-like values, such as MyEnumClassConstants and MyEnums. Just create some variables in the module level. Let us see how to do it just after the item below.
Also, why is getEnum() a classmethod? This can be a mere function and you have not to worry about conflicts because it is inside a module:
```
def getEnum(value, itr):
    for enumObj in itr:
        if enumObj.value == value:
            return enumObj
    return None
```
If you are going to set some variables with sequential numbers, you may want to use the unpacking idiom:
```
(
    ERROR1,
    ERROR2,
    ERROR3,
    ERROR4
) = range(1, 5)
```

This idiom can be used to create your list of enums, too:

_enums = (
    ErrorEnum1,
    ErrorEnum2,
    ErrorEnum3,
    ErrorEnum4
) = (
    MyEnumClass(ERROR1, "ERROR1"),
    MyEnumClass(ERROR2, "ERROR2"),
    MyEnumClass(ERROR3, "ERROR3"),
    MyEnumClass(ERROR4, "ERROR4")
)

To be honest, I would happily leave _enums as a public member of the module but let us take it easy with your Java-itis :P As we did with getEnum(), let us do with the other classmethods: declare them as functions in the module:
```
def getCount():
    return len(_enums)

def getList():
    return _enums
```

We can even improve the getEnum() by changing the default parameter:

def getEnum(value, itr=_enums):
    for enumObj in itr:
        if enumObj.value == value:
            return enumObj
    return None

I would also happily ban the __all__ declaration here. The only thing that is not part of the interface is the _enums tuple, and it is preceded by _ which, according to PEP-8, means it should not be used externally. But let us say it will stay. Your module has a new interface, with more constants and functions:
```
__all__ = ["MyEnumClass", "ERROR1", "ERROR2", "ERROR3", "ERROR4",
        "ErrorEnum1", "ErrorEnum2", "ErrorEnum3", "ErrorEnum4",
        "getCount", "getList", "getEnum"]
```
It seems it would be better to remove MyEnumClass from the interface but well, you may want to use it so I will leave it. Note, also that the __all__ value does not avoid the access to another components of the module. It just changes the documentation

The end result will be something like this:

__all__ = ["MyEnumClass", "ERROR1", "ERROR2", "ERROR3", "ERROR4",
        "ErrorEnum1", "ErrorEnum2", "ErrorEnum3", "ErrorEnum4",
        "getCount", "getList", "getEnum"]

class MyEnumClass(object):
    def __init__(self, value, description, ui = None):
        self.value = value
        self.description = description

(
    ERROR1,
    ERROR2,
    ERROR3,
    ERROR4
) = range(1, 5)


_enums = (
    ErrorEnum1,
    ErrorEnum2,
    ErrorEnum3,
    ErrorEnum4
) = (
    MyEnumClass(ERROR1, "ERROR1"),
    MyEnumClass(ERROR2, "ERROR2"),
    MyEnumClass(ERROR3, "ERROR3"),
    MyEnumClass(ERROR4, "ERROR4")
)

def getCount():
    return len(_enums)

def getList():
    return _enums

def getEnum(value, itr=_enums):
    for enumObj in itr:
        if enumObj.value == value:
            return enumObj
    return None

(EDITED) This is really not much simpler. If I would create error codes, I would merely create the ERROR1, ERROR2 etc. variables - no classes, no functions, just values in variables. Actually, even the idea of creating error codes seems inappropriate: you should prefer to create exceptions since, as the Zen of Python states, errors should never pass silently (or, as the Eric Raymond's Unix philosophy says, when you must fail, fail noisily and as soon as possible). Nonetheless, I bet the changes I've made can give you a more precise bit of taste of writing Python.

You may feel itches about doing things this way, but believe me, it is the best way. Some people may disagree in some points with me but the idea is the one presented. I am mostly a Java developer, but it is important to dance to the music of the language - do not try to force foreign concepts into it.

Finally, some important references:

PEP-20 - The Zen of Python: a somewhat poetic listing of core values in developing in Python and to Python.
PEP-8 - the style guide for Python. Read it right now.
Python is not Java - one of the best guides about avoiding inappropriate Java habits in Python.

I added another reference and edited one of the last paragraphs, adding some important points.
This is the Soap handling error. The exception is thrown one level up in the call stack. This just represents the Error state coming form the Soap message parsing.
One More question. How the classes are generally supposed to be categoried in python? Like in java we have packeges and then one class per file way of writing code. but python has modules which can contain multiple classes. so: 1. Should I write one class per module? 2. Should I combine classes in one module even if they are not related to each other? 3. Should I combine only when I have similar and related classes? I feel 3 is more correct way, but my java classes are in such a way that I will mostly end up one class per module or 10-20 of classes in a module in python...
@Ashutosh In fact, the third solution is the most common option: group the classes (and functions) that are correlated. This is a point where there is no universal standard. You should either follow the default structure of the project on which you are working, or to use the common sense, balancing the cohesion of correlated components and the size of the file.

Hugh Bothwell · Accepted Answer · 2012-06-26 20:56:15Z

0

in general, Python class properties are left public unless there's really good reason for them not to be.
if the property must be private, it is more Pythonic to use a @property decorator than a getProperty method.

.

class MyEnumBaseClass(object):
    def __init__(self, value, description, ui=None):
        self.value = value
        self._description = description
        self.ui = [] if ui is None else ui

    @property
    def description(self):
        return self._description

    @classmethod
    def get_enum(cls, value, itr):
        for enumObj in itr:
            if enumObj.value == value:
                return enumObj
        return None

answered Jun 26, 2012 at 20:56

Hugh Bothwell

57k9 gold badges91 silver badges103 bronze badges

Comments

Winston Ewert · Accepted Answer · 2012-06-26 21:56:16Z

0

A more pythonic approach:

class EnumValue(object):
    def __init__(self, value, description):
        self.value = value
        self.description = description

class EnumType(object):
    @classmethod
    def lookup(cls, value):
        for error in cls.VALUES:
            if error.value == value:
                return value
        raise ValueError(value)    

class MyErrors(EnumType):
    ERROR1 = EnumValue(1, "Simple Errors")
    ERROR2 = EnumValue(2, "Bigger Errors")
    ERROR3 = EnumValue(3, "Really Big Errors")

    VALUES = [ERROR1, ERROR2, ERROR3]

edited Jun 26, 2012 at 21:56

answered Jun 26, 2012 at 21:29

Winston Ewert

45.2k10 gold badges70 silver badges86 bronze badges

3 Comments

Ashutosh Over a year ago

I need the MyEnumBaseClass separate because there are other thousands of errorEnumClass like MyEnumClass that extends the MyEnumBaseClass. So, I can't move the lookup (getEnum) method to MyErrors (enums). I also need the constants so that I can compare or use them in other module/class. I hope this make sense and explain the constraints!

Winston Ewert Over a year ago

@Ashutosh, thousands? yikes! Pulling the common elements into a base class is easy, (see edit). You can access the constants as MyErrors.ERROR1.value, but needing them is suspicious. You should either always being a EnumValue object or always using the integer. Pick one and stick with it.

Ashutosh Over a year ago

I just realized I might have multiplied the number of error classes by a factor of 10 or 20. :)

Collectives™ on Stack Overflow

Pythonic way of rewrite Java code in Python

3 Answers 3

5 Comments

Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

5 Comments

Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related