refactoring/testing/adding help system

Author: docmarionum1

.gitignore

@@ -6,5 +6,6 @@
 /__pycache__/
 /dist/
 MANIFEST
+cover
 .coverage
-coverage.xml
+coverage.xml

geosupport/__init__.py

@@ -1,115 +1 @@
-from functools import partial
-import sys
-from .work_area_layouts import format_input, parse_output, GeosupportError
-
-FUNCTION_ALT_NAMES = {
-    '1': [],
-    '1a': [],
-    '1b': ['address'],
-    '1e': [],
-    '1n': ['street_name_to_street_code', 'get_street_code'],
-    '2': ['intersection'],
-    '2w': ['intersections', 'intersection_wide'],
-    '3': ['street_segment'],
-    '3c': ['blockface'],
-    '3s': ['street_stretch'],
-    'ap': ['address_point'],
-    'bb': ['browse_back'],
-    'bf': ['browse_forward'],
-    'bl': ['bbl', 'tax_lot', 'lot'],
-    'bn': ['bin', 'building'],
-    'd': ['get_street_name'],
-    'dg': [],
-    'dn': [],
-    'n*': ['normalize_street_name']
-}
-
-FUNCTIONS = {}
-
-for function, alt_names in FUNCTION_ALT_NAMES.items():
-    FUNCTIONS[function] = function
-    FUNCTIONS[function.upper()] = function
-    for name in alt_names:
-        FUNCTIONS[name] = function
-        FUNCTIONS[name.upper()] = function
-
-class Geosupport(object):
-    def __init__(self):
-        self.py_version = sys.version_info[0]
-        try:
-            self.platform = sys.platform
-            if sys.maxsize > 2 ** 32:
-                self.py_bit = '64'
-            else:
-                self.py_bit = '32'
-            if self.platform == 'win32':
-                if self.py_bit == '64':
-                    from ctypes import cdll
-                    self.geolib = cdll.LoadLibrary("NYCGEO.dll")
-                else:
-                    from ctypes import windll  # must use windll for 32-bit Windows binaries
-                    self.geolib = windll.LoadLibrary("NYCGEO.dll")
-            elif self.platform == 'linux' or self.platform == 'linux2':
-                import os
-                from ctypes import cdll
-                self.geolib = cdll.LoadLibrary(os.path.join(os.environ['LD_LIBRARY_PATH'], "libgeo.so"))
-            else:
-                raise Exception('This Operating System is currently not supported.')
-        except OSError as e:
-            sys.exit(
-                '{}\n'
-                'You are currently using a {}-bit Python interpreter. Is the installed '
-                'version of Geosupport {}-bit?'.format(e, self.py_bit, self.py_bit))
-
-    def _call_geolib(self, flags, wa1, wa2):
-        """
-        Calls the Geosupport libs & encodes/deocodes strings for Python 3.
-        :param wa1: Work Area 1
-        :param wa2: Work Area 2
-        :param func: Function that determines the dictionary to return.
-        :return: Dictionary of results
-        """
-
-        # encode
-        if self.py_version == 3:
-            wa1 = bytes(str(wa1), 'utf8')
-            wa2 = bytes(str(wa2), 'utf8')
-
-        # Call Geosupport libs
-        if self.platform == 'win32':
-            self.geolib.NYCgeo(wa1, wa2)  # windows
-        else:
-            self.geolib.geo(wa1, wa2)  # linux
-
-        # decode
-        if self.py_version == 3:
-            wa1 = str(wa1, 'utf8')
-            wa2 = str(wa2, 'utf8')
-
-        #print(wa1)
-        #print(wa2)
-
-        return parse_output(flags, wa1, wa2)
-
-    def __getattr__(self, name):
-        if name in FUNCTIONS:
-            return partial(self.call, function=FUNCTIONS[name])
-
-        raise AttributeError("'%s' object has no attribute '%s'" %(
-            self.__class__.__name__, name
-        ))
-
-    def __getitem__(self, name):
-        return self.__getattr__(name)
-
-    def call(self, kwargs_dict={}, **kwargs):
-        kwargs_dict.update(kwargs)
-        flags, wa1, wa2 = format_input(kwargs_dict)
-        result = self._call_geolib(flags, wa1, wa2)
-        return_code = result['Geosupport Return Code (GRC)']
-        if not return_code.isdigit() or int(return_code) > 1:
-            raise GeosupportError(
-                result['Message'] + ' ' + result['Message 2'],
-                result
-            )
-        return result
+from geosupport.geosupport import Geosupport

geosupport/config.py

@@ -0,0 +1,19 @@
+from os import path
+
+FUNCTION_INFO_PATH = path.join(
+    path.abspath(path.dirname(__file__)),
+    'function_info'
+)
+
+FUNCTION_INFO_CSV = path.join(FUNCTION_INFO_PATH, 'function_info.csv')
+FUNCTION_INPUTS_CSV = path.join(FUNCTION_INFO_PATH, 'function_inputs.csv')
+WORK_AREA_LAYOUTS_PATH = path.join(FUNCTION_INFO_PATH, 'work_area_layouts')
+
+BOROUGHS = {
+    'MANHATTAN': 1, 'MN': 1, 'NEW YORK': 1, 'NY': 1,
+    'BRONX': 2, 'THE BRONX': 2, 'BX': 2,
+    'BROOKLYN': 3, 'BK': 3, 'BKLYN': 3, 'KINGS': 3,
+    'QUEENS': 4, 'QN': 4, 'QU': 4,
+    'STATEN ISLAND': 5, 'SI': 5, 'STATEN IS': 5, 'RICHMOND': 5,
+    '': '',
+}

geosupport/error.py

@@ -0,0 +1,4 @@
+class GeosupportError(Exception):
+    def __init__(self, message, result={}):
+        super(GeosupportError, self).__init__(message)
+        self.result = result

geosupport/function_info.py

@@ -0,0 +1,169 @@
+from csv import DictReader
+import glob
+from os import path
+
+from geosupport.config import FUNCTION_INFO_CSV, FUNCTION_INPUTS_CSV, WORK_AREA_LAYOUTS_PATH
+
+MODES = ['regular', 'extended', 'long', 'long+tpad']
+AUXILIARY_SEGMENT_LENGTH = 500
+
+class FunctionDict(dict):
+
+    def __init__(self):
+        super(FunctionDict, self).__init__()
+        self.alt_names = {}
+
+    def __getitem__(self, name):
+        name = str(name).strip().upper()
+        if self.alt_names and name in self.alt_names:
+            name = self.alt_names[name]
+
+        return super(FunctionDict, self).__getitem__(name)
+
+    def __contains__(self, name):
+        name = str(name).strip().upper()
+
+        return (
+            (name in self.alt_names) or
+            (super(FunctionDict, self).__contains__(name))
+        )
+
+def load_function_info():
+    FUNCTIONS = FunctionDict()
+
+    alt_names = {}
+
+    with open(FUNCTION_INFO_CSV) as f:
+        csv = DictReader(f)
+        for row in csv:
+            function = row['function']
+            for k in MODES:
+                if row[k]:
+                    row[k] = int(row[k])
+                else:
+                    row[k] = None
+
+            if row['alt_names']:
+                row['alt_names'] = [
+                    n.strip() for n in row['alt_names'].split(',')
+                ]
+            else:
+                row['alt_names'] = []
+
+            for n in row['alt_names']:
+                alt_names[n.upper()] = function
+
+            row['inputs'] = []
+
+            FUNCTIONS[function] = row
+
+    FUNCTIONS.alt_names = alt_names
+
+    with open(FUNCTION_INPUTS_CSV) as f:
+        csv = DictReader(f)
+
+        for row in csv:
+            if row['function']:
+                FUNCTIONS[row['function']]['inputs'].append({
+                    'name': row['field'],
+                    'comment': row['comments']
+                })
+
+    return FUNCTIONS
+
+def list_functions():
+    s = sorted([
+        "%s (%s)" % (
+            function['function'], ', '.join(function['alt_names'])
+        ) for function in FUNCTIONS.values()
+    ])
+    s = ["List of functions (and alternate names):"] + s
+    s.append("\nUse Geosupport.help(<function>) to read about specific function.")
+    return '\n'.join(s)
+
+def function_help(function):
+    function = FUNCTIONS[function]
+
+    s = [
+        "%s (%s)" % (function['function'], ', '.join(function['alt_names'])),
+        "="*40,
+        function['description'],
+        "",
+        "Input: %s" % function['input'],
+        "Output: %s" % function['output'],
+        "Modes: %s" % ', '.join([
+            m for m in MODES if function[m] is not None
+        ]),
+        "",
+        "Inputs",
+        "="*40,
+    ]
+
+    for i in function['inputs']:
+        s.append("%s - %s" % (i['name'], i['comment']))
+
+    s = "\n".join(s)
+
+    return s
+
+FUNCTIONS = load_function_info()
+
+def load_work_area_layouts():
+    WORK_AREA_LAYOUTS = {}
+
+    for csv in glob.glob(path.join(WORK_AREA_LAYOUTS_PATH, '*', '*.csv')):
+        directory = path.basename(path.dirname(csv))
+        if directory not in WORK_AREA_LAYOUTS:
+            WORK_AREA_LAYOUTS[directory] = {}
+
+        layout = {}
+        name = path.basename(csv).split('.')[0]
+
+        if '-' in name:
+            functions, mode = name.split('-')
+            mode = '-' + mode
+        else:
+            functions = name
+            mode = ''
+
+        functions = functions.split('_')
+        for function in functions:
+            WORK_AREA_LAYOUTS[directory][function + mode] = layout
+
+        '''df = pd.read_csv(
+            csv, encoding='latin-1', dtype={'from': int, 'to': int, 'formatter': str}
+        ).fillna('')'''
+
+        with open(csv) as f:
+            rows = DictReader(f)
+
+            for row in rows:
+                name = row['name'].strip().strip(':').strip()
+
+                parent = row['parent'].strip().strip(':').strip()
+                if parent and 'i' in layout[parent]:
+                    layout[parent] = {parent: layout[parent]}
+
+                alt_names = [
+                    n.strip() for n in row['alt_names'].split(',') if n
+                ]
+
+                v = {
+                    'i': (int(row['from']) - 1, int(row['to'])),
+                    #'formatter': get_formatter(row['formatter'])
+                    'formatter': row['formatter']
+                }
+
+                if parent:
+                    layout[parent][name] = v
+                else:
+                    layout[name] = v
+
+                for n in alt_names:
+                    layout[n] = v
+                    layout[n.upper()] = v
+                    layout[n.lower()] = v
+
+    return WORK_AREA_LAYOUTS
+
+WORK_AREA_LAYOUTS = load_work_area_layouts()