Create package with backward compatibility

Question

I'm try to create python package in 3.6 But I also want backward compatibility to 2.7 How can I write a code for 3.6 and 2.7

For example I have method called geo_point().

def geo_point(lat: float, lng: float):
    pass

This function work fine in 3.6 but not in 2.7 it show syntax error I think 2.7 not support type hinting. So I want to write another function which is supported by 2.7 and when user run my package on 2.7 it ignore all the function which is not supported

For example

 @python_version(2.7)
 def geo_point(lat, lng):
     pass

Is it possible to have both function and python decide which function is compatible?

Answer 1

If type hinting is the only issue you have with your code, then look at SO question Type hinting in Python 2

It says, that python3 respects also type hinting in comment lines. Python2 will ignore it and python3 respects this alternative syntax. It has specifically been designed for code that still had to be python2 compatible.

However please note, that just because the code compiles with python2, it doesn't mean it will yield the correct result.

If you have more compatibility issues I strongly propose to look at the future module (not to be mixed up with the from __future__ import xxx statement.

You can install future ( https://pypi.org/project/future/ ) with pip install future.

As you don't show any other code that causes problems I cannot advise on specific issues.

The url https://python-future.org/compatible_idioms.html shows a quite extensive list of potential python 2 / python 3 issues and how you might resolve them.

For example for opening files in python 2 with less encoding / unicode issues can be done by importing an alternative version of open with the line

from io import open

https://python-future.org/compatible_idioms.html

Addendum:

If you really are in the need of declaring one function for python3 and one function for python2 you can do:

import sys

if sys.version_info < (3, 0):
    def myfunc(a, b):  # python 2 compatible function
        bla bla bla
else:
    def myfunc(a, b):  # python 3 compatible function
        bla bla bla

However: Both function must be syntactically correct for python 2 and python 3

If you really want to have functions, which are only python2 or only python3 syntactically correct (e.g. print statement or await), then you could do something like:

import sys

if sys.version_info < (3, 0):
    from myfunc_py2 import myfunc  # the file myfunc_py2.py does not have to be python3 compatible
else:
    from myfunc_py3 import myfunc  # the file myfunc_py3.py does not have to be python2 compatible

Answer 2

I doubt it's worth the trouble, but as a proof of concept: You could use a combination of a decorator and the built-in exec() function. Using exec() is a way to avoid syntax errors due to language differences.

Here's what I mean:

import sys

sys_vers_major, sys_vers_minor, sys_vers_micro = sys.version_info[:3]
sys_vers = sys_vers_major + sys_vers_minor*.1 # + sys_vers_micro*.01
print('sys_vers: %s' % sys_vers)

def python_version(vers, code1, code2):
    lcls = {}  # Dictionary to temporarily store  version of function defined.

    if sys_vers == vers:
        exec(code1, globals(), lcls)
    else:
        exec(code2, globals(), lcls)

    def decorator(func):
        return lcls[func.__name__]

    return decorator


@python_version(2.7,
"""
def geo_point(lat, lng):
    print('code1 version')
""",
"""
def geo_point(lat: float, lng: float):
    print('code2 version')
""")
def geo_point(): pass  # Needed to know name of function that's being defined.

geo_point(121, 47)  # Show which version was defined.

Answer 3

I think 2.7 not support type hinting

Actually, Python 2 supports type hinting, and you can write backwards-compatible code. See the answer about Python 2 type hinting on StackOverflow.

Answer 4

While the other answers emphasize type hinting, I'm thinking that the

Six package

may be of help. The project base and link to documentation is at https://pypi.org/project/six/.

Six is a Python 2 and 3 compatibility library. It provides utility functions for smoothing over the differences between the Python versions with the goal of writing Python code that is compatible on both Python versions. See the documentation for more information on what is provided.

One of the notable differences between Python 2 and Python 3 is that lack of parens in a print statement will cause a syntax error in Python 3, for example,

print "Hello, World"  # OK in Python 2, syntax error in Python 3.

Six addresses these differences.