fix namespace clashes

* modeule name solar_utils.py was shadowing package
 solar_utils/__init__.py so changed it to core.py
* also change solar_utils.solar_utils to solar_utils.core in
 solar_utils/__init__.py where it imports solposAM and spectrl2
 and in setup.py where it's used to import __version__ and __name__ from
 solar_utils/__init__.py
* change solar_utils_excpetions to just exceptions
* fixed solposAM the exported DLL function was shadowing solposAM() the
 Python function so made it _solposAM with preceding underscore
* ditto for spectrl2
* gitignore venv/ and spyderproject files
* remove logging from setup.py
* don't create extral LDFLAGS constant, just call make_ldflags() inside
 link_shared_lib() call for extra_preargs
* add if clause to remove libs if clean in sys.argv, then don't run tests
* add release name to package __init__.py
* combine imports from solar_utils.exceptions in core
* change arg x to err_code in _int2bits() to make pylint happy :)
* change code to err_code everywhere since code is a builtin Python function
* change atmosphericConditions to atomspheric_conditions everywhere,
 oops! this will break pvsimlife :(
* in tests, change rel_diff lambda to constant REL_DIFF
* get rid of intermediate values in spectrl2 tests
* line up spaces, change fp to filepath and do what pylint likes :|

Author: mikofski

.gitignore

@@ -1,4 +1,5 @@
 # build
+venv/
 build/
 dist/
 solar_utils.egg-info/
@@ -21,6 +22,7 @@ solar_utils.egg-info/
 .pydevproject
 SolarUtils.sublime-workspace
 SolarUtils.sublime-project
+.spyderproject
 
 # sphinx
 docs/_build/

setup.py

@@ -11,12 +11,9 @@
     sys.exit('setuptools was not detected - please install setuptools and pip')
 from solar_utils import __version__ as VERSION, __name__ as NAME
 from solar_utils.tests import test_cdlls
-import logging
 
-logging.basicConfig(level=logging.DEBUG)
-LOGGER = logging.getLogger(__name__)
 # set platform constants
-CCFLAGS, RPATH, INSTALL_NAME, LDFLAGS = None, None, None, None
+CCFLAGS, RPATH, INSTALL_NAME = None, None, None
 PLATFORM = sys.platform
 if PLATFORM == 'win32':
     SRC_DIR = 'win32'
@@ -71,8 +68,14 @@ def make_ldflags(lib_name, rpath=RPATH, install_name=INSTALL_NAME):
     os.path.exists(os.path.join(LIB_DIR, SPECTRL2_LIB_FILE))
 ])
 
-# build libraries if they don't exist
-if not LIB_FILES_EXIST:
+# run clean or build libraries if they don't exist
+if 'clean' in sys.argv:
+    try:
+        os.remove(os.path.join(LIB_DIR, SOLPOSAM_LIB_FILE))
+        os.remove(os.path.join(LIB_DIR, SPECTRL2_LIB_FILE))
+    except OSError as err:
+        sys.stderr.write('%s\n' % err)
+elif not LIB_FILES_EXIST:
     # clean build directory
     if os.path.exists(BUILD_DIR):
         shutil.rmtree(BUILD_DIR)  # delete entire directory tree
@@ -84,26 +87,22 @@ def make_ldflags(lib_name, rpath=RPATH, install_name=INSTALL_NAME):
     OBJS = CC.compile([SOLPOS, SOLPOSAM], output_dir=BUILD_DIR,
                       extra_preargs=CCFLAGS)
     # link objects and make shared library in build directory
-    LDFLAGS = make_ldflags(SOLPOSAM_LIB)  # make linker option flags for compiler
-    LOGGER.debug('%s LDFLAGS: %r', SPECTRL2_LIB, LDFLAGS)
     CC.link_shared_lib(OBJS, SOLPOSAM_LIB, output_dir=BUILD_DIR,
-                       extra_preargs=LDFLAGS)
+                       extra_preargs=make_ldflags(SOLPOSAM_LIB))
     # compile spectrl2 objects into build directory
     OBJS = CC.compile([SPECTRL2, SPECTRL2_2, SOLPOS], output_dir=BUILD_DIR,
                       extra_preargs=CCFLAGS)
     CC.set_libraries([SOLPOSAM_LIB])  # set linked libraries
     CC.set_library_dirs([BUILD_DIR])  # set library directories
     # link objects and make shared library in build directory
-    LDFLAGS = make_ldflags(SPECTRL2_LIB)  # make linker option flags for compiler
-    LOGGER.debug('%s LDFLAGS: %r', SPECTRL2_LIB, LDFLAGS)
     CC.link_shared_lib(OBJS, SPECTRL2_LIB, output_dir=BUILD_DIR,
-                       extra_preargs=LDFLAGS)
+                       extra_preargs=make_ldflags(SPECTRL2_LIB))
     # copy files from build to library folder
     shutil.copy(os.path.join(BUILD_DIR, SOLPOSAM_LIB_FILE), LIB_DIR)
     shutil.copy(os.path.join(BUILD_DIR, SPECTRL2_LIB_FILE), LIB_DIR)
-# test libraries
-test_cdlls.test_solposAM()
-test_cdlls.test_spectrl2()
+    # test libraries
+    test_cdlls.test_solposAM()
+    test_cdlls.test_spectrl2()
 
 setup(name=NAME,
       version=VERSION,

solar_utils/__init__.py

@@ -7,8 +7,9 @@
 Do Not Distribute
 """
 
-from solar_utils import solposAM, spectrl2
+from solar_utils.core import solposAM, spectrl2
 
 __version__ = '0.1.1'
+__release__ = 'Aerial Acrobats'
 __author__ = 'Mark Mikofski'
 __all__ = ['solposAM', 'spectrl2']

solar_utils/solar_utils.py solar_utils/core.py

@@ -18,9 +18,7 @@
 import math
 import os
 import sys
-
-from solar_utils_exceptions import SOLPOS_Error
-from solar_utils_exceptions import SPECTRL2_Error
+from solar_utils.exceptions import SOLPOS_Error, SPECTRL2_Error
 
 _DIRNAME = os.path.dirname(__file__)
 if sys.platform == 'win32':
@@ -35,19 +33,18 @@
     PLATFORM = 'darwin'
     SOLPOSAM = 'libsolposAM.dylib'
     SPECTRL2 = 'libspectrl2.dylib'
-
 SOLPOSAMDLL = os.path.join(_DIRNAME, PLATFORM, SOLPOSAM)
 SPECTRL2DLL = os.path.join(_DIRNAME, PLATFORM, SPECTRL2)
 
 
-def _int2bits(x):
+def _int2bits(err_code):
     """
     Convert integer to bits.
 
     :param x: integer to convert
     :returns: log(x, 2)
     """
-    return int(math.log(x, 2))
+    return int(math.log(err_code, 2))
 
 
 def solposAM(location, datetime, weather):
@@ -63,11 +60,11 @@ def solposAM(location, datetime, weather):
     :type weather: list of floats
     :returns: angles, airmass
     :rtype: float
-    :raises: :exc:`~solar_utils.solar_utils_exceptions.SOLPOS_Error`
+    :raises: :exc:`~solar_utils.exceptions.SOLPOS_Error`
     """
     # load the DLL
-    solposAMdll = ctypes.cdll.LoadLibrary(SOLPOSAMDLL)
-    solposAM = solposAMdll.solposAM
+    solposAM_dll = ctypes.cdll.LoadLibrary(SOLPOSAMDLL)
+    _solposAM = solposAM_dll.solposAM
     # cast Python types as ctypes
     _location = (ctypes.c_float * 3)(*location)
     _datetime = (ctypes.c_int * 6)(*datetime)
@@ -79,14 +76,14 @@ def solposAM(location, datetime, weather):
     orientation = (ctypes.c_float * 2)()
     shadowband = (ctypes.c_float * 3)()
     # call DLL
-    code = solposAM(_location, _datetime, _weather, angles, airmass, settings,
-                    orientation, shadowband)
+    err_code = _solposAM(_location, _datetime, _weather, angles, airmass,
+                         settings, orientation, shadowband)
     # return results if successful, otherwise raise SOLPOS_Error
-    if code == 0:
+    if err_code == 0:
         return angles, airmass
     else:
-        # convert code to bits
-        _code = _int2bits(code)
+        # convert err_code to bits
+        _code = _int2bits(err_code)
         data = {'location': location,
                 'datetime': datetime,
                 'weather': weather,
@@ -99,7 +96,7 @@ def solposAM(location, datetime, weather):
 
 
 def spectrl2(units, location, datetime, weather, orientation,
-             atmosphericConditions, albedo):
+             atmospheric_conditions, albedo):
     """
     Calculate solar spectrum by calling functions exported by
     :data:`SPECTRL2DLL`.
@@ -114,14 +111,14 @@ def spectrl2(units, location, datetime, weather, orientation,
     :type weather: list of floats
     :param orientation: tilt and aspect [degrees]
     :type orientation: list of floats
-    :param atmosphericConditions: alpha, assym, ozone, tau500 and watvap
-    :type atmosphericConditions: list of floats
+    :param atmospheric_conditions: alpha, assym, ozone, tau500 and watvap
+    :type atmospheric_conditions: list of floats
     :param albedo: 6 wavelengths and 6 reflectivities
     :type albedo: list of lists of floats
     :returns: specdif, specdir, specetr, specglo and specx
     :rtype: float
-    :raises: :exc:`~solar_utils.solar_utils_exceptions.SPECTRL2_Error`,
-        :exc:`~solar_utils.solar_utils_exceptions.SOLPOS_Error`
+    :raises: :exc:`~solar_utils.exceptions.SPECTRL2_Error`,
+        :exc:`~solar_utils.exceptions.SOLPOS_Error`
 
     .. seealso::
         :func:`solposAM`
@@ -133,23 +130,22 @@ def spectrl2(units, location, datetime, weather, orientation,
     >>> datetime = [1999, 7, 22, 9, 45, 37]
     >>> weather = [1006.0, 27.0]
     >>> orientation = [33.65, 135.0]
-    >>> atmosphericConditions = [1.14, 0.65, -1.0, 0.2, 1.36]
+    >>> atmospheric_conditions = [1.14, 0.65, -1.0, 0.2, 1.36]
     >>> albedo = [0.3, 0.7, 0.8, 1.3, 2.5, 4.0] + ([0.2] * 6)
     >>> (specdif, specdir, specetr, specglo,
          specx) = spectrl2(units, location, datetime, weather, orientation,
-                           atmosphericConditions, albedo)
+                           atmospheric_conditions, albedo)
     """
-    # requires 'solpos.dll'
     # load the DLL
-    ctypes.cdll.LoadLibrary(SOLPOSAMDLL)
-    spectrl2DLL = ctypes.cdll.LoadLibrary(SPECTRL2DLL)
-    spectrl2 = spectrl2DLL.spectrl2
+    ctypes.cdll.LoadLibrary(SOLPOSAMDLL)  # requires 'solpos.dll'
+    spectrl2_dll = ctypes.cdll.LoadLibrary(SPECTRL2DLL)
+    _spectrl2 = spectrl2_dll.spectrl2
     # cast Python types as ctypes
     _location = (ctypes.c_float * 3)(*location)
     _datetime = (ctypes.c_int * 6)(*datetime)
     _weather = (ctypes.c_float * 2)(*weather)
     _orientation = (ctypes.c_float * 2)(*orientation)
-    _atmosphericConditions = (ctypes.c_float * 5)(*atmosphericConditions)
+    _atmospheric_conditions = (ctypes.c_float * 5)(*atmospheric_conditions)
     _albedo = (ctypes.c_float * 12)(*albedo)
     # allocate space for results
     specdif = (ctypes.c_float * 122)()
@@ -162,21 +158,23 @@ def spectrl2(units, location, datetime, weather, orientation,
     settings = (ctypes.c_int * 2)()
     shadowband = (ctypes.c_float * 3)()
     # call DLL
-    code = spectrl2(units, _location, _datetime, _weather, _orientation,
-                    _atmosphericConditions, _albedo, specdif, specdir, specetr,
-                    specglo, specx, angles, airmass, settings, shadowband)
+    err_code = _spectrl2(
+        units, _location, _datetime, _weather, _orientation,
+        _atmospheric_conditions, _albedo, specdif, specdir, specetr, specglo,
+        specx, angles, airmass, settings, shadowband
+    )
     # return results if successful, otherwise raise exception
-    if code == 0:
+    if err_code == 0:
         return specdif, specdir, specetr, specglo, specx
-    elif code < 0:
+    elif err_code < 0:
         data = {'units': units,
-                'tau500': atmosphericConditions[3],
-                'watvap': atmosphericConditions[4],
-                'assym': atmosphericConditions[1]}
-        raise SPECTRL2_Error(code, data)
+                'tau500': atmospheric_conditions[3],
+                'watvap': atmospheric_conditions[4],
+                'assym': atmospheric_conditions[1]}
+        raise SPECTRL2_Error(err_code, data)
     else:
-        # convert code to bits
-        _code = _int2bits(code)
+        # convert err_code to bits
+        _code = _int2bits(err_code)
         data = {'location': location,
                 'datetime': datetime,
                 'weather': weather,

solar_utils/solar_utils_exceptions.py solar_utils/exceptions.py

@@ -20,12 +20,12 @@
 from nose.tools import ok_
 
 from solar_utils import *
-from solar_utils.solar_utils_exceptions import SOLPOS_Error, SPECTRL2_Error
+from solar_utils.exceptions import SOLPOS_Error, SPECTRL2_Error
 
 _DIRNAME = os.path.dirname(__file__)
 TOL = 1E-3
 
-reldiff = lambda (x, x0): np.abs(x - x0) / x0
+RELDIFF = lambda (x, x0): np.abs(x - x0) / x0
 
 
 def test_solposAM():
@@ -41,10 +41,10 @@ def test_solposAM():
     # call test function
     angles, airmass = solposAM(location, datetime, weather)
     # test OUTPUTS are within TOL
-    ok_(reldiff((angles[0], test_data['angles'][0])) < TOL)
-    ok_(reldiff((angles[1], test_data['angles'][1])) < TOL)
-    ok_(reldiff((airmass[0], test_data['airmass'][0])) < TOL)
-    ok_(reldiff((airmass[1], test_data['airmass'][1])) < TOL)
+    ok_(RELDIFF((angles[0], test_data['angles'][0])) < TOL)
+    ok_(RELDIFF((angles[1], test_data['angles'][1])) < TOL)
+    ok_(RELDIFF((airmass[0], test_data['airmass'][0])) < TOL)
+    ok_(RELDIFF((airmass[1], test_data['airmass'][1])) < TOL)
     # test errors - YEAR
     datetime = [2051, 6, 5, 12, 31, 0]
     try:
@@ -89,53 +89,48 @@ def test_spectrl2():
     """
     # test data
     test_data_jsonfile = 'test_spectrl2_data.json'
-    with open(os.path.join(_DIRNAME, test_data_jsonfile), 'r') as fp:
-        test_data = json.load(fp)
+    with open(os.path.join(_DIRNAME, test_data_jsonfile), 'r') as filepath:
+        test_data = json.load(filepath)
     units = 1
     location = [33.65, -84.43, -5.0]
     datetime = [1999, 7, 22, 9, 45, 37]
     weather = [1006.0, 27.0]
     orientation = [33.65, 135.0]
-    atmosphericConditions = [1.14, 0.65, -1.0, 0.2, 1.36]
+    atmospheric_conditions = [1.14, 0.65, -1.0, 0.2, 1.36]
     albedo = [0.3, 0.7, 0.8, 1.3, 2.5, 4.0] + ([0.2] * 6)
     # call test function
     (specdif, specdir, specetr, specglo,
      specx) = spectrl2(units, location, datetime, weather, orientation,
-                       atmosphericConditions, albedo)
+                       atmospheric_conditions, albedo)
     # convert OUTPUT to numpy arrays
     _specdif = np.ctypeslib.as_array(specdif)  # use ctypeslib
     _specdir = np.ctypeslib.as_array(specdir)
     _specetr = np.ctypeslib.as_array(specetr)
     _specglo = np.ctypeslib.as_array(specglo)
     _specx = np.ctypeslib.as_array(specx)
     # test OUTPUT are within TOL
-    delta_specdif = reldiff((_specdif, test_data['specdif']))
-    assert np.all(delta_specdif < TOL)
-    delta_specdir = reldiff((_specdir, test_data['specdir']))
-    assert np.all(delta_specdir < TOL)
-    delta_specetr = reldiff((_specetr, test_data['specetr']))
-    assert np.all(delta_specetr < TOL)
-    delta_specglo = reldiff((_specglo, test_data['specglo']))
-    assert np.all(delta_specglo < TOL)
-    delta_specx = reldiff((_specx, test_data['specx']))
-    assert np.all(delta_specx < TOL)
+    assert np.all(RELDIFF((_specdif, test_data['specdif'])) < TOL)
+    assert np.all(RELDIFF((_specdir, test_data['specdir'])) < TOL)
+    assert np.all(RELDIFF((_specetr, test_data['specetr'])) < TOL)
+    assert np.all(RELDIFF((_specglo, test_data['specglo'])) < TOL)
+    assert np.all(RELDIFF((_specx, test_data['specx'])) < TOL)
     # raise a SPECTRL2_Error - UNITS
     try:
         spectrl2(3, location, datetime, weather, orientation,
-                       atmosphericConditions, albedo)
+                 atmospheric_conditions, albedo)
     except SPECTRL2_Error as err:
         assert err.args[0] == -1
     # raise a SPECTRL2_Error - TAU500
     try:
         spectrl2(units, location, datetime, weather, orientation,
-                       [-1.0] * 5, albedo)
+                 [-1.0] * 5, albedo)
     except SPECTRL2_Error as err:
         assert err.args[0] == -2
     # now raise a SOLPOS_Error - YEAR
     datetime = [2051, 6, 5, 12, 31, 0]
     try:
         spectrl2(units, location, datetime, weather, orientation,
-                       atmosphericConditions, albedo)
+                 atmospheric_conditions, albedo)
     except SOLPOS_Error as err:
         assert err.args[0] == 'S_YEAR_ERROR'