arc-utils 1.2.1__py3-none-any.whl

arc_utils/__init__.py

@@ -0,0 +1,10 @@
+"""A collection of python utilities for ArcGIS Pro
+"""
+__version__ = '1.1'
+__author__ = 'Grant Herbert'
+
+__all__ = ['aprx.py', 'gdb.py', 'table.py']
+
+from arc_utils import gdb
+from arc_utils import table
+from arc_utils import aprx

arc_utils/aprx.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+"""ArcGIS Pro aprx related utilities
+"""
+
+import arcpy
+
+class AprxObj(object):
+    """ provide methods for working with a ArcGIS Pro aprx file
+    all standard arcpy methods are available via .aprx
+    Usage: pro_doc = arc_utils.aprx.AprxObj(path)
+    :param
+        path: a string representing an aprx file, 
+        or "CURRENT" if used in ArcGIS Pro Python window
+    """
+    def __init__(self, aprx_path):
+        """ :param path to aprx or "CURRENT"
+        """
+        self.aprx = arcpy.mp.ArcGISProject(aprx_path)
+        self.path = aprx_path
+        self.maps = self.get_maps()
+        self.layouts = self.get_layouts()
+        
+    def get_maps(self):
+        """ :return array of map objects"""
+        map_array = []
+        for map in self.aprx.listMaps():
+            map_array.append(map)
+        return map_array
+
+    def get_layouts(self):
+        """ :return array of layout objects"""
+        layout_array = []
+        for layout in self.aprx.listLayouts():
+            layout_array.append(layout)
+        return layout_array
+
+    def get_layer_obj_as_array(self, map):
+        """ :param: map object
+        :return array of layer objects in a specified map object"""
+        layer_obj_array = []
+        for layer in map.listLayers():
+            layer_obj_array.append(layer)
+        return layer_obj_array
+
+    def get_layer_names_as_array(self, map):
+        """ :param: map object
+        :return array of layer names in a specified map object"""
+        lyr_name_array = []
+        for layer in map.listLayers():
+            lyr_name_array.append(layer.name)
+        return lyr_name_array
+
+    def layer_obj_generator(self, map):
+        """ :param: map object
+        yields layer objects"""
+        for layer in map.listLayers():
+            yield layer
+
+    def layer_names_generator(self, map):
+        """ :param: map object
+        yields layer names"""
+        for layer in map.listLayers():
+            yield layer.name
+

arc_utils/gdb.py

@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+"""utilities for working with geodatabases and reporting on geodatabase contents
+"""
+from __future__ import print_function, unicode_literals, absolute_import
+import os
+import arcpy
+from .output import get_valid_output_path
+from .output import output_msg
+
+class GDBObj(object):
+    """ provide properties for working with a GDB
+    Usage: gdb = arc_utils.gdb.GDBObj(path)
+    :param
+        path: a string representing a GDB connection/path
+    """
+    def __init__(self, gdb_path):
+        """ sets up reference to table
+        adds properties and methods
+        """
+        self.path = gdb_path
+        self.describe_obj = self._describe_object()
+        self.feature_classes = self.get_feature_class_names()
+        self.tables = self.get_table_names()
+        self.domain_names = self.get_all_domain_names()
+
+    def _describe_object(self):
+        """ returns describe object"""
+        return arcpy.Describe(self.path)
+        
+    def get_feature_class_names(self):
+        """ get a list of all the featureclass names"""
+        fc_list = []
+        temp_ws = arcpy.env.workspace
+        arcpy.env.workspace = self.path
+        datasets = arcpy.ListDatasets(feature_type='feature')
+        datasets = [''] + datasets if datasets is not None else []
+        for dataset in datasets:
+            for fc in arcpy.ListFeatureClasses(feature_dataset=dataset):
+                fc_list.append(fc)
+        arcpy.env.workspace = temp_ws
+        return fc_list
+        
+    def get_table_names(self):
+        """ get a list of all the table names"""
+        tbl_list = []
+        temp_ws = arcpy.env.workspace
+        arcpy.env.workspace = self.path
+        tbls = arcpy.ListTables()
+        for tbl in tbls:
+            tbl_list.append(tbl)
+        arcpy.env.workspace = temp_ws
+        return tbl_list
+
+    def get_all_domain_names(self):
+        domain_names = []
+        domains = arcpy.da.ListDomains(self.path)
+        for domain in domains:
+            domain_names.append(domain.name)
+        return domain_names
+
+    def OID_check(self):
+        for fc in self.feature_classes:
+            oidfield = ''
+            tmp = arcpy.Describe(fc)
+            if tmp.hasOID:
+                oidfield = tmp.OIDFieldName
+            print('featureclass', tmp.name, tmp.hasOID, oidfield)
+        for tb in self.tables:
+            oidfield = ''
+            tmp = arcpy.Describe(tb)
+            if tmp.hasOID:
+                oidfield = tmp.OIDFieldName
+            print('table', tmp.name, tmp.hasOID, oidfield)
+
+#TODO split into 3 - get all FC, create formatted string output, write to file. use io
+def report_all_fc_as_text(geodatabase, output_file=None, sep='\t'):
+    """Create a text report of all fields in all featureclasses/tables from a geodatabase
+    to specified output file.
+
+    :param geodatabase {String}
+        Path or reference to a geodatabase.
+    
+    :param output_file {String}
+        Path or reference to a text file. If not supplied defaults to gdb directory.
+    
+    :param sep {String}
+        seperator value (eg ',' or r'\t'
+    """
+    default_env = arcpy.env.workspace
+    try:
+        desc = arcpy.Describe(geodatabase)
+        arcpy.env.workspace = geodatabase
+        if not output_file:
+            path = get_valid_output_path(desc.Path)
+            output_file = os.path.join(path, desc.name.split(".")[0] + ".txt")
+
+        output_msg("Writing to: {0}".format(output_file))
+        # list all datasets
+        datasets = arcpy.ListDatasets(feature_type='feature')
+        datasets = [''] + datasets if datasets is not None else []
+        # write out gdb info, fields etc
+        with open(output_file, "w") as logFile:
+            header = ["FCDataset","Feature"]
+            atts = ['name', 'baseName', 'aliasName', 'type', 'length', 'precision', 'scale',
+                    'domain', 'defaultValue', 'editable', 'isNullable', 'required']
+            header.extend(atts)
+            header_output = sep.join(["{}".format(i) for i in header])
+            logFile.write(header_output + "\n")
+            for tbl in arcpy.ListTables():
+                output_msg("Processing Table: {0}".format(tbl))
+                try:
+                    fields = arcpy.ListFields(tbl)
+                    str_output = ""
+                    line_start = "{0}{1}{2}{1}".format("", sep, tbl)
+                    for field in fields:
+                        str_output += line_start + sep.join(["{}".format(getattr(field, i)) for i in atts])
+                        str_output += "\n"
+                    logFile.write(str_output)
+
+                except Exception as e:
+                    output_msg(str(e.args[0]))
+                    output_msg(arcpy.GetMessages())
+                    continue
+
+            for dataset in datasets:
+                for fc in arcpy.ListFeatureClasses(feature_dataset=dataset):
+                    output_msg("Processing Dataset: {0} \ FeatureClass: {1}".format(dataset, fc))
+                    try:
+                        fields = arcpy.ListFields(fc)
+                        str_output = ""
+                        line_start = "{0}{1}{2}{1}".format(dataset, sep, fc)
+                        for field in fields:
+                            str_output += line_start + sep.join(["{}".format(getattr(field, i)) for i in atts])
+                            str_output += "\n"
+                        logFile.write(str_output)
+
+                    except Exception as e:
+                        output_msg(str(e.args[0]))
+                        output_msg(arcpy.GetMessages())
+                        continue
+
+    except Exception as e:
+        output_msg(str(e.args[0]))
+        output_msg(arcpy.GetMessages())
+    finally:
+        arcpy.env.workspace = default_env
+        output_msg("Completed")
+
+
+def export_all_domains(geodatabase, workspace=None):
+    """Output all the domains in a geodatabase
+    to tables in a workspace.
+
+    :param geodatabase {String}:
+        Path or reference to input geodatabase.
+    
+    :param workspace {String}: Optional
+        Path to output folder or geodatabase. Defaults to input geodatabase.
+    """
+    try:
+        if not workspace:
+            workspace = geodatabase
+        domains = arcpy.da.ListDomains(geodatabase)
+        for domain in domains:
+            dname = arcpy.ValidateTableName(domain.name + '_domain', workspace)
+            output = os.path.join(workspace, dname)
+            if workspace != geodatabase:
+                output += '.txt'
+            output_msg('Exporting {0} domain to {1}'.format(domain.name, dname))
+            arcpy.DomainToTable_management(geodatabase, domain.name, output, "codedValues", 'description')
+
+    except Exception as e:
+        output_msg(str(e.args[0]))
+        output_msg(arcpy.GetMessages())
+    finally:
+        output_msg("Completed")
+
+
+def import_tables_as_domains(tables, geodatabase):
+    """import tables as domains into geodatabase. Expects fields 'codedValues' and 'description'
+    
+    :param tables {string}
+        path or array of paths of input tables containing domain data
+    
+    :param geodatabase
+        Path or reference to geodatabase."""
+    try:
+        for table in tables:
+            desc = arcpy.Describe(table)
+            dname = desc.name.replace("_domain", "")
+            arcpy.TableToDomain_management(table, "codedValues", "description", geodatabase, dname)
+    except Exception as e:
+        output_msg(str(e.args[0]))
+        output_msg(arcpy.GetMessages())
+    finally:
+        output_msg("Completed")

arc_utils/output.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+"""output related utilities
+"""
+from __future__ import print_function, unicode_literals, absolute_import
+import arcpy
+import os
+
+def output_msg(msg, severity=0):
+    """Output msg to print and/or to Arc. Useful to include in a tool
+    that can be run in Python or in ArcGIS
+
+    msg{String}:
+        message to output.
+
+    severity(integer):
+        severity = 0 (none), 1 (warning), 2 (error)
+    usage:
+        output_msg("message")
+
+    function from http://help.arcgis.com/en/arcgisdesktop/10.0/help/index.html#//00150000000p000000.htm
+    """
+
+    # Adds a Message (in case this is run as a tool)
+    # and also prints the message to the screen (standard output)
+    #
+    print(msg)
+
+    # Split the message on \n first, so that if it's multiple lines,
+    #  a GPMessage will be added for each line
+    try:
+        for string in msg.split('\n'):
+            # Add appropriate geoprocessing message
+            #
+            if severity == 0:
+                arcpy.AddMessage(string)
+            elif severity == 1:
+                arcpy.AddWarning(string)
+            elif severity == 2:
+                arcpy.AddError(string)
+    except:
+        pass
+
+
+def get_valid_output_path(path, folder_reqd=True, make_dir=True):
+    """ return a valid path for an output, eg a folder path.
+    If folder_reqd is True (default) and a gdb is passed as path,
+    will drop down to the folder containing gdb.
+    If path does not exist and make_dir is True (default)
+    folder will be created.
+    Otherwise will default to userprofile\documents folder
+    path {String}:
+        filepath
+    folder_reqd {Boolean}:
+        returned path must be a folder
+    make_dir {Boolean}:
+        make the directory if not exists
+    :return path
+    """
+    report_dir = path
+    if os.path.isdir(path):
+        if folder_reqd:
+            if path.lower().endswith(".gdb"):
+                report_dir = arcpy.Describe(path).Path
+    elif make_dir:
+        os.makedirs(path)
+        report_dir = path
+    else:
+        report_dir = os.environ['USERPROFILE']
+        if os.path.exists(report_dir + "\\Documents"):
+            report_dir = report_dir + "\\Documents"
+
+    return report_dir
+
+
+def output_to_file(data, path, filename):
+    """send result string to file"""
+    path = get_valid_output_path(path)
+    output_file = os.path.join(path, filename)
+    with open(output_file, "w") as output:
+        output_file.write('{}').format(data)

arc_utils/table.py

@@ -0,0 +1,502 @@
+# -*- coding: utf-8 -*-
+"""utilities for working with tables, featureclasses and fields
+"""
+from __future__ import print_function, unicode_literals, absolute_import
+import arcpy
+from .output import get_valid_output_path
+from .output import output_msg
+
+
+class TableObj(object):
+    """ provide properties for working with a table/featureclass
+    Usage: tbl = arc_utils.table.TableObj(path)
+    :param
+        path: a string representing an table/featureclass
+    """
+    def __init__(self, table_path):
+        """ sets up reference to table
+        adds properties and methods
+        """
+        self.path = table_path
+        self.describe_obj = self._describe_object()
+        self.name = self._get_fc_name()
+        self.type = self._get_fc_type()
+        self.field_dict = self._make_field_dict()
+        self.fields = self._list_field_names()
+        self.fields2 = self._list_field_names(required=False)
+        self.fieldaliases = self._list_field_names(aliases=True)
+        
+
+    def _describe_object(self):
+        """ returns describe object"""
+        return arcpy.Describe(self.path)
+
+    def _get_fc_name(self):
+        return self.describe_obj.baseName
+
+    def _get_fc_type(self):
+        if hasattr(self.describe_obj, 'shapeType'):
+            return self.describe_obj.shapeType
+        elif hasattr(self.describe_obj, 'dataType'):
+            return self.describe_obj.dataType
+        else:
+            return 'Unknown'
+
+    def _list_field_names(self, required=True, aliases=False):
+        """Array of field names
+        """
+        if required:
+            f_list = [field['name'] for field in self.field_dict.values()]
+        else:
+            f_list = [field['name'] for field in self.field_dict.values() if not field['required']]
+        if aliases:
+            # override the output to use aliases instead of field names
+            f_list = [self.field_dict[field]['aliasName'] for field in f_list]
+        return f_list
+
+    def _make_field_dict(self):
+        """Dictionary of fields containing
+        all properties exposed by the arcpy.ListFields tool
+        """
+        field_dict = dict()
+        for field in arcpy.ListFields(self.path):
+            field_dict[field.name] = {
+                "name": field.name,
+                "baseName": field.baseName,
+                "aliasName": field.aliasName,
+                "type": field.type,
+                "length": field.length,
+                "required": field.required,
+                "domain": field.domain,
+                "defaultValue": field.defaultValue,
+                "precision": field.precision,
+                "scale": field.scale,
+                "isNullable": field.isNullable,
+                "editable": field.editable
+            }
+        return field_dict
+
+    def get_field_info_as_text(self, sep="\t"):
+        """ Create a delimeter separated output of a table's fields and their properties
+            :param sep {String}
+                Separator value to use. eg r"\t" for tab (default), "," for comma
+            :return string of values with separator between
+        """
+        str_output = sep.join("{}\n".format(self.field_dict.keys()))
+        for k in self.field_dict.keys():
+            str_output += self.field_dict[k] + sep
+        str_output += "\n"
+        return str_output
+
+    def get_max_field_value(self, field, lengthcomp=False):
+        """Return the largest value (if numeric).
+        lexicographic string comparison is used to determine largest value for strings by default.
+            :param {String} field:
+            name of the field to parse
+            :param {Boolean} lengthcomp:
+            If True will compare strings for length rather than lexicographically (ascii value of letters)
+        """
+        field_type = self.field_dict[field]['type']
+        if field_type in ["Geometry"]:
+            print("Cannot process Geometry field")
+            return None
+        elif field_type in ["String"]:
+            result = ''
+        else:
+            result = 0
+        with arcpy.da.SearchCursor(self.path, field) as values:
+            for value in values:
+                if value[0] is not None:
+                    val = value[0]
+                    if field_type in ["String"] and lengthcomp:
+                        if len(val) > len(result):
+                            result = val
+                    else:
+                        if val > result:
+                            result = val
+        return result
+
+    def get_max_field_value_length(self, field):
+        """Return the length of the maximum value in the field.
+            :param: field {String}:
+            name of the field to parse
+        """
+        length = 0
+        with arcpy.da.SearchCursor(self.path, field) as values:
+            for value in values:
+                if value[0] is not None:
+                    val = str(value[0])
+                    if len(val) > length:
+                        length = len(val)
+        return length
+
+    def get_field_value_set(self, field):
+        """Return set of unique field values
+            :param field {String}:
+                name of the field to parse
+            :return set of unique values. Null values are represented as 'NULL' string
+           """
+        try:
+            value_set = set()  # set to hold unique values
+            with arcpy.da.SearchCursor(self.path, field) as values:
+                for value in values:
+                    if value[0] is None:
+                        value_set.add("NULL")
+                    else:
+                        value_set.add(value[0])
+            return value_set
+
+        except arcpy.ExecuteError:
+            output_msg(arcpy.GetMessages(2))
+        except Exception as e:
+            output_msg(e.args[0])
+
+    def get_multiple_field_value_set(self, fields, sep=':'):
+        """return a set of unique field values for an input table
+        and any number of fields (values will be concatenated with sep)
+        :param fields {array of String values}:
+            single field name or an array of field names (['Field1', 'Field2'])
+        :param sep {String}:
+            character to use as a separator (default = ':'
+        """
+        if not isinstance(fields, list):
+            fieldslist = [fields]
+        else:
+            fieldslist = fields
+
+        result = set()
+        
+        with arcpy.da.SearchCursor(self.path, fieldslist) as cursor:
+            for row in cursor:
+                parts = [('NULL' if v is None else str(v)) for v in row]
+                result.add(sep.join(parts))
+
+        return set(result)
+
+    def find_duplicate_field_values(self, field, charset='ascii'):
+        """Return set of unique field values
+            :param field {String}:
+                name of the field to parse
+            :param: charset {String}:
+                character set to use (default = 'ascii').
+                Valid values are those in the Python documentation for string encode.
+            :return set of values which are duplicated in the field (ignores Null values).
+           """
+        try:
+            dup_set = set()  # set to hold duplicate values
+            value_set = set()  # set to hold unique values
+            with arcpy.da.SearchCursor(self.path, field) as values:
+                for value in values:
+                    if value[0] in value_set:
+                        dup_set.add(value[0])
+                    else:
+                        value_set.add(value[0])
+            return dup_set
+
+        except arcpy.ExecuteError:
+            output_msg(arcpy.GetMessages(2))
+        except Exception as e:
+            output_msg(e.args[0])
+
+    def find_duplicate_field_values_as_df(path, fields):
+        """Return set of unique field values
+            :param path {String}:
+                path to data
+            :param field [{String}]:
+                list of name(s) of fields to parse
+            :return Pandas DataFrame of values which are duplicated in the field with count > 1 (ignores Null values).
+            Use Pandas DataFrame <result>.to_csv() to export to file
+        """
+        if not isinstance(fields, list):
+            fieldslist = [fields]
+        else:
+            fieldslist = fields
+        
+        import pandas
+        data = arcpy.da.TableToNumPyArray(path, fieldslist, null_value='NULL')
+        df = pandas.DataFrame(data)
+        count = df.groupby(fields).size().reset_index().rename(columns={0:'count'})
+        dups = count[count['count'] > 1]
+        return dups
+    
+    def export_schema_to_csv(self, path):
+        """Create a csv schema report of all fields in a featureclass,
+        to the supplied path.
+        """
+        import datetime
+        import os
+        import csv
+        # TODO convert to use csv
+        start_time = datetime.datetime.today()
+        start_date_string = start_time.strftime('%Y%m%d')
+        default_env = arcpy.env.workspace
+        fc = self.path
+        delimiter = ','
+        # nice to convert reported types to types accepted by add field tool
+        type_conversions = {"String": "TEXT", "Float": "FLOAT", "Double": "DOUBLE", "SmallInteger": "SHORT",
+                            "Integer": "LONG", "Date": "DATE", "Blob": "BLOB", "Raster": "RASTER", "GUID": "GUID",
+                            "TRUE": "True", "FALSE": "False", "Geometry": "GEOMETRY", "OID": "OID"}
+
+        output_msg("Processing: {}".format(self.path))
+
+        try:
+            fc_type = self.type
+
+            report_dir = get_valid_output_path(path)
+            out_file_name = self.name + "_Field_Report " + start_date_string + ".csv"
+            out_file_path = os.path.join(report_dir, out_file_name)
+            output_msg("Report file: {0}".format(out_file_path))
+            with open(out_file_path, "w") as logFile:
+                #logFile.write("Type,{}\n".format(fc_type))
+                logFile.write(
+                    "FieldName,FieldType,FieldPrecision,FieldScale,FieldLength,FieldAlias,isNullable,Required,"
+                    "FieldDomain,DefaultValue,Editable,BaseName\n")
+
+                for field in self.field_dict:
+                    output_msg("Writing {}".format(field))
+                    logFile.write("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11}\n".format(
+                        self.field_dict[field]['name'],
+                        type_conversions[self.field_dict[field]['type']],
+                        self.field_dict[field]['precision'],
+                        self.field_dict[field]['scale'],
+                        self.field_dict[field]['length'],
+                        self.field_dict[field]['aliasName'],
+                        self.field_dict[field]['isNullable'],
+                        self.field_dict[field]['required'],
+                        self.field_dict[field]['domain'],
+                        self.field_dict[field]['defaultValue'],
+                        self.field_dict[field]['editable'],
+                        self.field_dict[field]['baseName'])
+                    )
+
+            return out_file_path
+        except Exception as e:
+            output_msg("error: " + str(e.args[0]))
+            output_msg(arcpy.GetMessages())
+
+    def compare_field_values_to_domain(self, field, gdb, domain_name):
+        """compare field values with domain values
+            return a named tuple (matched = values in domain,
+            unmatched = values outside of domain
+            NULL is skipped
+
+            :param field {string}
+                Field name
+            :param gdb {string}
+                Geodatabase path
+            :param domain_name {string}
+                Domain name in gdb
+        """
+        from collections import namedtuple
+        nt = namedtuple('Result', 'match unmatched')
+        field_values = self.get_field_value_set(field)
+        domain_values = []
+        domain_type = None
+        field_in_domain = []
+        field_out_domain = []
+        domains = arcpy.da.ListDomains(gdb)
+        for domain in domains:
+            if domain.name == domain_name:
+                if domain.domainType == 'CodedValue':
+                    domain_type = 'CodedValue'
+                    coded_values = domain.codedValues
+                    for code, descr in coded_values.items():
+                        domain_values.append(code)
+                elif domain.domainType == 'Range':
+                    domain_type = 'Range'
+                    domain_values.append(domain.range[0])
+                    domain_values.append(domain.range[1])
+                break
+        if domain_type == 'Range':
+            # compare upper and lower bounds
+            for fv in field_values:
+                if fv == 'NULL':
+                    continue
+                elif int(fv) < domain_values[0] or int(fv) > domain_values[1]:
+                    field_out_domain.append(fv)
+                else:
+                    field_in_domain.append(fv)
+        else:
+            for fv in field_values:
+                if type(fv) == bytes: # Python 3 catch as domain values are strings
+                    fv = fv.decode()
+                if fv in domain_values:
+                    field_in_domain.append(fv)
+                else:
+                    field_out_domain.append(fv)
+
+        return nt(field_in_domain, field_out_domain)
+
+    def pretty_print(self):
+        """ pretty print a table's fields and their properties
+        """
+        def _print(l):
+            print("".join(["{:>12}".format(i) for i in l]))
+
+        atts = ['name', 'aliasName', 'type', 'baseName', 'domain',
+                'editable', 'isNullable', 'length', 'precision',
+                'required', 'scale', ]
+        _print(atts)
+
+        for f in arcpy.ListFields(self.path):
+            _print(["{:>12}".format(getattr(f, i)) for i in atts])
+
+
+    def get_max_field_value(input_fc, field, treatasfloat=False):
+        """Return either the longest string in the field,
+        or the largest number.
+            :param input_fc {String}:
+                Path or reference to feature class or table.
+            :param field {String}:
+                name of the field to parse
+            :param treatasfloat:
+                setting to treat the field as a float value (expects all numeric)
+            :return value of largest field entry
+        """
+        result = None
+        with arcpy.da.SearchCursor(input_fc, field) as values:
+                for value in values:
+                    if value[0] is not None:
+                        if treatasfloat:
+                            val = float(value[0])
+                        else:
+                            val = value[0]
+                        if isinstance(val, str):
+                            # return longest string
+                            if result is None:
+                                result = ''
+                            if len(val) > len(result):
+                                result = val
+                        else:
+                            if result is None:
+                                result = 0
+                            if val > result:
+                                result = val
+        return result
+
+
+def export_field_sets(fc_list, out_xlsx, ignore_fields=["objectid","globalid"], use_lyr_alias=True):
+    """ Export unique field values for each layer in a list to an Excel file with one sheet per layer
+    :param fc_list: list of feature class or table paths
+    :param out_xlsx: path to output Excel file
+    :param ignore_fields: list of lowercase fields to ignore (e.g. ['objectid', 'shape'])
+    :param use_lyr_alias: if True, use layer alias for sheet name;"""
+	import os
+	from openpyxl import Workbook
+
+    ignore_fields = [v.lower() for v in ignore_fields]
+
+	# Create workbook
+	wb = Workbook()
+	# Remove the default sheet that openpyxl creates
+	default_sheet = wb.active
+	wb.remove(default_sheet)
+
+	# Loop through layers and create a sheet per layer
+	for lyr in layr_list:
+		tbl = TableObj(lyr)
+
+		print(f'Processing name: {tbl.name}, alias: {str(lyr)}')
+
+		# Excel sheet name must be <= 31 chars and cannot contain: : \ / ? * [ ]
+		if use_lyr_alias:
+			raw_name = str(lyr)
+		else:
+			raw_name = str(tbl.name) if hasattr(tbl, "name") else str(lyr)
+		safe_name = "".join(ch for ch in raw_name if ch not in r':\/?*[]')
+		safe_name = safe_name[:31] if len(safe_name) > 31 else safe_name
+		if not safe_name:
+			safe_name = "Sheet"
+
+		ws = wb.create_sheet(title=safe_name)
+
+		# Header row
+		ws["A1"] = "Field"
+		ws["B1"] = "Values"
+
+		row_idx = 2
+
+		for fld in tbl.fields2:  # skip required fields by default
+			if fld.lower() in ignore_fields:
+                continue
+
+            #get field alias if available
+            if fld in tbl.field_dict and 'aliasName' in tbl.field_dict[fld] and tbl.field_dict[fld]['aliasName']:
+                alias = tbl.field_dict[fld]['aliasName']
+            else:
+                alias = fld
+			# Get unique values for the field
+			vals = tbl.get_field_value_set(fld)
+
+			# Convert to sorted, comma-separated string
+			# Make sure everything is a string for consistency
+			vals_str = ", ".join(sorted(str(v) for v in vals))
+
+			# Write to Excel
+            ws.cell(row=row_idx, column=1, value=alias)    # Column A: field alias/name
+			try:
+			    ws.cell(row=row_idx, column=2, value=vals_str) # Column B: CSV of unique values
+            except Exception as e:
+			    ws.cell(row=row_idx, column=2, value="VALUES ERROR") # Column B: error msg
+                print(f"Error writing field '{alias}' values to Excel: {e}")
+            row_idx += 1
+                
+	# Save workbook
+	wb.save(out_xlsx)
+	print(f"\nExcel file written to: {out_xlsx}")
+
+
+def compare_schema(fc1, fc2):
+    """compare the schemas of two tables. Return an array of results.
+    :param fc1 {String}:
+            Path or reference to feature class or table.
+    :param fc2 {String}:
+            Path or reference to feature class or table.
+    :return array of results (field not found, field same, etc)
+    """
+    result_arr= []
+    fcobj1 = TableObj(fc1)
+    fcobj2 = TableObj(fc2)
+    field_dict1 = fcobj1.field_dict
+    field_dict2 = fcobj2.field_dict
+    for ifield in sorted(list(set(field_dict1.keys()+field_dict2.keys()))):
+        # check name for missing fields first
+        if not (field_dict1.has_key(ifield)):
+            the_result = " {0} not found in {1}".format(ifield, fc1)
+            output_msg(the_result)
+            result_arr.append(the_result)
+        elif not (field_dict2.has_key(ifield)):
+            the_result = " {0} not found in {1}".format(ifield, fc2)
+            output_msg(the_result)
+            result_arr.append(the_result)
+        else:
+            # string comparison of name, type and length
+            if field_dict1[ifield] == field_dict2[ifield]:
+                the_result = " {0} field same in both".format(ifield)
+                output_msg(the_result)
+                result_arr.append(the_result)
+            else:
+                the_result = "Field Mismatch {}: ({}, {}) ".format(
+                    ifield, fc1, fc2)
+                for k in field_dict1[ifield]:
+                    if field_dict1[ifield][k] != field_dict2[ifield][k]:
+                        the_result += '{}: ({}, {}) '.format(k, field_dict1[ifield][k], field_dict2[ifield][k])
+                output_msg(the_result)
+                result_arr.append(the_result)
+
+    return result_arr
+
+
+def import_schema_to_fc(csv_file, fc_name):
+    """convert csv schema from report_fields_to_csv_schema
+    to a featureclass"""
+    # assume headers as per output from export_schema_to_csv
+    # get fc type from csv file line 1
+    # load the csv file from line 2 for field info
+    # get field list
+    # ignore OBJECTID, SHAPE
+    fields_to_ignore =["OBJECTID", "GLOBALID","FID", "SHAPE", "SHAPE_AREA", "SHAPE.AREA", "SHAPE.STAREA()", "SHAPE_LENGTH", "SHAPE.LEN", "SHAPE.STLENGTH()"]
+    # create fc from fc_name
+    # add fields from field list
+    # arcpy.AddField_management(in_table, field_name, field_type, {field_precision}, {field_scale}, {field_length}, {field_alias}, {field_is_nullable}, {field_is_required}, {field_domain})
+    return None

arc_utils-1.2.1.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: arc-utils
+Version: 1.2.1
+Summary: Python utilities for use with Esri ArcGIS Pro software
+Author-email: Grant Herbert <gdherbert@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/gdherbert/arc_utils
+Project-URL: Download, https://github.com/gdherbert/arc_utils/tree/1.2
+Keywords: esri,arcpy,arcgis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+# README #
+
+
+### What is this repository for? ###
+* A collection of (mostly) arcpy related utilities for use within ArcGIS Pro (Python 3).
+Shortcuts for accessing elements of a map document, performing various data discovery tasks on a table or geodatabase
+
+### How do I get set up? ###
+
+* To install the utilities: 
+* ``pip install arc_utils``
+* Clone the repo to your machine and add the path to the python install https://docs.python.org/2/tutorial/modules.html#the-module-search-path
+* Optionally, you can copy the folder to the site-packages in the ESRI python install directory, or add a .pth file to the site-packages folder pointing to the clone directory.
+
+To use the utilities:
+
+* in the python window in ArcGIS Pro
+
+``import arc_utils as au``
+
+* typing ``au.`` will now reveal the modules and functions available to you if you have autocomplete on
+
+* Depends on arcpy (only available with Esri license)
+
+### Example usage ###
+
+``import arc_utils as au``
+
+``tbl = au.table.TableObj(path to featureclass)``
+
+# list all fields 
+
+``print(tbl.fields)``
+
+``pro_doc = au.aprx.AprxObj(“CURRENT”)``
+
+``pro_doc.maps`` >> [<arcpy._mp.Map object at 0x000001A4AECBF108>, <arcpy._mp.Map object at 0x000001A4AEBB6608>]
+
+``pro_doc.maps[0].name`` >> ‘Map’
+
+### Contribution guidelines ###
+
+Contributions welcomed, this is a starting point for various utilities that I think could be useful within ArcGIS Pro.

arc_utils-1.2.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+arc_utils/__init__.py,sha256=NqPSgtw3GDpN5dltKc5Dl_x4sirGg4cDHdkd9e1L1ZY,239
+arc_utils/aprx.py,sha256=VahUkYu-X4OR7vdncBbNSY_V96Ouu-txeqCHCF5uJ1k,2043
+arc_utils/gdb.py,sha256=Cy8RmCSyRYaCwHItv477-ECRdKLlSuUA2aA5BkgBhxA,7721
+arc_utils/output.py,sha256=0zq2hrnYQXiE5EABsiG-HTkaPpT4K-r89Mve4s2ctfI,2533
+arc_utils/table.py,sha256=lB8o-hl23gTTLCp0tSbnFleNWR1dflZHQwKo2dBuvlw,20631
+arc_utils-1.2.1.dist-info/licenses/LICENSE.txt,sha256=utsApqHdbH4b8YLRL99aOiW7p1_QXOs1WN1oagYbzVw,1089
+examples/extract-featureclass-details.py,sha256=SFvudfiqR3L8POFqDLgUWr52c5yGn2gy2ipx62Vy6FE,4199
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=2rsbUMkHvXwFF9mKvQqNTAxcTPxPUpS2krKyXHUVYd0,3347
+tests/test_aprx.py,sha256=Or02a0xFdSMiMFjtxjohthKw5kFKw6Qb7zjadVfjpok,774
+tests/test_gdb.py,sha256=N5sAJxvIxbLP0qU6_orcBQG_lsWOp7fzqcdYJhRBObE,541
+tests/test_table.py,sha256=HPPknGOaWB0JJ_rAPshzeW_f7WfjN0vwwCcfwGBgok0,2650
+arc_utils-1.2.1.dist-info/METADATA,sha256=t9iTDfaR8rLUVItfuN13WgPxPO0zOAR6vA1KnYzxTSA,2161
+arc_utils-1.2.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+arc_utils-1.2.1.dist-info/top_level.txt,sha256=rw_nJqzaer4UzqCOdnxEy6oZ5UqmLF0sI_u05cLF8zc,25
+arc_utils-1.2.1.dist-info/RECORD,,

arc_utils-1.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

arc_utils-1.2.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Grant Herbert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

arc_utils-1.2.1.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+arc_utils
+examples
+tests

examples/extract-featureclass-details.py

@@ -0,0 +1,124 @@
+import arc_utils as au
+import arcpy
+import os
+
+
+def write_field_info(fc):
+    desc = arcpy.Describe(fc)
+    root_path = desc.path
+    fc_name = desc.name
+    print('getting field info from %s' % fc_name)
+    if fc_name.find(".") != -1:
+        fc_name = fc_name.split(".")[0]
+    a = open(os.path.join(root_path, fc_name + ".tsv"), "w")
+    a.write(au.table.get_field_info_as_text(fc))  # use default tab
+    a.flush()
+    a.close()
+
+
+def write_field_values(fc):
+    import csv
+    desc = arcpy.Describe(fc)
+    root_path = desc.path
+    print(root_path)
+    fc_name = desc.name
+    print('getting field values from %s' % fc_name)
+    if fc_name.find(".") != -1:
+        fc_name = fc_name.split(".")[0]
+    field_value_csv = os.path.join(root_path, fc_name + "_field_values.csv")
+    with open(field_value_csv, 'a+') as a:
+        csvw = csv.writer(a, lineterminator='\n')
+        fco = au.table.TableObj(fc)
+        for field in fco.fields2:
+            print('writing field values for %s' % field)
+            values = [field]
+            values.extend(fco.get_field_value_set(field))
+            csvw.writerow(values)
+
+
+def get_featureclass_info(workspace):
+    ws = arcpy.env.workspace
+    arcpy.env.workspace = workspace
+    desc = arcpy.Describe(workspace)
+    root_path = workspace
+    if not desc.dataType == 'Folder':
+        root_path = desc.catalogPath  # path
+    for fc in arcpy.ListFeatureClasses():
+        fc_path = os.path.join(arcpy.env.workspace, fc)
+        # write field info
+        write_field_info(fc_path)
+        # write field values
+        write_field_values(fc_path)
+    arcpy.env.workspace = ws
+
+
+def export_field_sets(layr_list, out_xlsx, ignore_fields=[], use_lyr_alias=True):
+    """ Export unique field values for each layer in a list to an Excel file with one sheet per layer
+    :param layr_list: list of layer objects or paths to layers
+    :param out_xlsx: path to output Excel file
+    :param ignore_fields: list of lowercase fields to ignore (e.g. ['objectid', 'shape'])
+    :param use_lyr_alias: if True, use layer alias for sheet name;"""
+	import os
+	from openpyxl import Workbook
+
+    ignore_fields = [v.lower() for v in ignore_fields]
+
+	# Create workbook
+	wb = Workbook()
+	# Remove the default sheet that openpyxl creates
+	default_sheet = wb.active
+	wb.remove(default_sheet)
+
+	# Loop through layers and create a sheet per layer
+
+	for lyr in layr_list:
+		tbl = au.table.TableObj(lyr)
+
+		print(f'Processing name: {tbl.name}, alias: {str(lyr)}')
+
+		# Excel sheet name must be <= 31 chars and cannot contain: : \ / ? * [ ]
+		if use_lyr_alias:
+			raw_name = str(lyr)
+		else:
+			raw_name = str(tbl.name) if hasattr(tbl, "name") else str(lyr)
+		safe_name = "".join(ch for ch in raw_name if ch not in r':\/?*[]')
+		safe_name = safe_name[:31] if len(safe_name) > 31 else safe_name
+		if not safe_name:
+			safe_name = "Sheet"
+
+		ws = wb.create_sheet(title=safe_name)
+
+		# Header row
+		ws["A1"] = "Field"
+		ws["B1"] = "Values"
+
+		row_idx = 2
+
+		for fld in tbl.fields2:
+			if fld.lower() in ignore_fields:
+                continue
+
+            #get field alias if available
+            if fld in tbl.field_dict and 'aliasName' in tbl.field_dict[fld] and tbl.field_dict[fld]['aliasName']:
+                alias = tbl.field_dict[fld]['aliasName']
+            else:
+                alias = fld
+			# Get unique values for the field
+			vals = tbl.get_field_value_set(fld)
+
+			# Convert to sorted, comma-separated string
+			# Make sure everything is a string for consistency
+			vals_str = ", ".join(sorted(str(v) for v in vals))
+
+			# Write to Excel
+            ws.cell(row=row_idx, column=1, value=alias)    # Column A: field alias/name
+			try:
+			    ws.cell(row=row_idx, column=2, value=vals_str) # Column B: CSV of unique values
+            except Exception as e:
+			    ws.cell(row=row_idx, column=2, value="VALUES ERROR") # Column B: error msg
+                print(f"Error writing field '{alias}' values to Excel: {e}")
+            row_idx += 1
+                
+	# Save workbook
+	wb.save(out_xlsx)
+	print(f"\nExcel file written to: {out_xlsx}")

tests/conftest.py

@@ -0,0 +1,76 @@
+"""module wide test fixtures"""
+import pytest
+import arcpy
+import os
+import random
+import collections
+
+testfolder = 'tests'
+
+@pytest.fixture(scope='module')
+def testgdb(pytestconfig):
+    gdb_name = "arc_utils_test_tmp.gdb"
+    return str(pytestconfig.rootdir.join(testfolder).join(gdb_name))
+
+@pytest.fixture(scope='module')
+def testaprx(pytestconfig):
+    aprx_name = "arc_utils_test_pro.aprx"
+    return str(pytestconfig.rootdir.join(testfolder).join(aprx_name))
+
+@pytest.fixture(scope='module')
+def testdatabase(request, testgdb):
+    # create a testing gdb
+    print("Creating test geodatabase")
+    testgdbpath = testgdb # os.path.join(arcpy.env.scratchFolder, "arc_utils_test.gdb")
+    if arcpy.Exists(testgdbpath):
+        print("Deleting " + testgdbpath)
+        arcpy.Delete_management(testgdbpath)
+    arcpy.CreateFileGDB_management(os.path.dirname(testgdbpath), os.path.basename(testgdbpath))
+    # add a domain for each field in testfc
+    ftext_dom_name = "ftext_coded"
+    fint_dom_name = "fint_range"
+    arcpy.CreateDomain_management(in_workspace=testgdbpath,
+                                  domain_name=ftext_dom_name,
+                                  domain_description="text domain",
+                                  field_type="TEXT",
+                                  domain_type="CODED")
+    arcpy.CreateDomain_management(in_workspace=testgdbpath,
+                                  domain_name=fint_dom_name,
+                                  field_type="SHORT",
+                                  domain_type="RANGE")
+    ftextDict = {"val1": "val1", "val2": "val2", "val3": "val3"}
+    for code in ftextDict:
+        arcpy.AddCodedValueToDomain_management(testgdbpath, ftext_dom_name, code, ftextDict[code])
+    arcpy.SetValueForRangeDomain_management(testgdbpath, fint_dom_name, 1, 12)
+    print("Creating test featureclasses")
+    sr = arcpy.SpatialReference(4326)
+    fc_names = ['test_fc', 'test_fc2']
+    fc_paths = []
+    fc_fields = (('ftext', 'TEXT', None, None, 20, '', 'NULLABLE', 'NON_REQUIRED', ftext_dom_name),
+                 ('fint', 'SHORT', 0, 0, 0, '', 'NULLABLE', 'NON_REQUIRED', fint_dom_name))
+
+    for name in fc_names:
+        arcpy.CreateFeatureclass_management(testgdbpath, name, "POINT", spatial_reference=sr)
+        fc = os.path.join(testgdbpath, name)
+        fc_paths.append(fc)
+        for fc_field in fc_fields:
+            arcpy.AddField_management(fc, *fc_field)
+        print("loading data")
+        records = (("val1", None),("val1", 4), ("val1", 4), ("val2", 7), ("val02", 7), ("val1", 10), ("val2", 5), ("val1", 10), ("val2", 5), ("val1", None), (None, 5))
+        with arcpy.da.InsertCursor(fc, ["ftext", "fint", "SHAPE@XY"]) as cursor:
+            for key, val in records:
+                lon = -122.3 + float(random.randint(-9, 9)) / 100
+                lat = 47.6 + float(random.randint(-9, 9)) / 100
+                cursor.insertRow([key, val, (lon, lat)])
+
+    result = collections.namedtuple('testdata', 'gdb, test_fc1, test_fc2')
+    result.gdb = testgdbpath
+    result.fc1 = fc_paths[0]
+    result.fc2 = fc_paths[1]
+
+    def testdata_teardown():
+        print('Deleting test geodatabase')
+        arcpy.Delete_management(testgdbpath)
+
+    request.addfinalizer(testdata_teardown)
+    return result

tests/test_aprx.py

@@ -0,0 +1,23 @@
+import sys
+if sys.version_info.major == 3:
+    from arc_utils import aprx
+
+    def test_aprxobj_properties(testaprx):
+        aprxobj = aprx.AprxObj(testaprx)
+        assert aprxobj.path == testaprx
+        assert aprxobj.maps[0].name == 'Map'
+        assert aprxobj.layouts[0].name == 'MyLayout'
+        
+
+    def test_aprxobj_layer_names(testaprx):
+        aprxobj = aprx.AprxObj(testaprx)
+        assert aprxobj.get_layer_names_as_array(aprxobj.maps[0]) == ['test_fc', 'Topographic']
+
+
+    def test_aprxobj_layer_obj(testaprx):
+        aprxobj = aprx.AprxObj(testaprx)
+        map_layer_obj = aprxobj.get_layer_obj_as_array(aprxobj.maps[0])
+        assert isinstance(map_layer_obj, list)
+        assert map_layer_obj[0].name == 'test_fc'
+        
+

tests/test_gdb.py

@@ -0,0 +1,14 @@
+from arc_utils import gdb
+
+def test_gdb_properties(testdatabase):
+    gdbpath = testdatabase.gdb
+    gdbobj = gdb.GDBObj(gdbpath)
+    assert gdbobj.path == gdbpath
+    assert isinstance(gdbobj.feature_classes, list)
+    assert isinstance(gdbobj.domain_names, list)
+
+def test_gdb_content(testdatabase):
+    gdbpath = testdatabase.gdb
+    gdbobj = gdb.GDBObj(gdbpath)
+    assert sorted(gdbobj.get_feature_class_names()) == ['test_fc', 'test_fc2']
+    assert sorted(gdbobj.get_all_domain_names()) == ['fint_range', 'ftext_coded']

tests/test_table.py

@@ -0,0 +1,69 @@
+from arc_utils import table
+import collections
+import os
+
+def test_tableobj_properties(testdatabase):
+    # test table object properties
+    testdata = testdatabase
+    tbl = table.TableObj(testdata.fc1)
+    assert tbl.name == 'test_fc'
+    assert tbl.path == testdata.fc1
+    assert tbl.type == u'Point'
+    assert tbl.fields == [u'OBJECTID', u'Shape', u'ftext', u'fint']
+    assert tbl.fields2 == [u'ftext', u'fint']
+    assert tbl.field_dict['Shape']['type'] == u'Geometry'
+    assert tbl.field_dict['ftext']['aliasName']== u'ftext'
+    assert tbl.field_dict['OBJECTID']['required']== True
+    assert tbl.field_dict['fint']['type']== u'Integer'
+
+
+def test_tableobj_single_text_field_methods(testdatabase):
+    # test table object methods
+    tbl = table.TableObj(testdatabase.fc1)
+    ftext_set = tbl.get_field_value_set('ftext')
+    assert isinstance(ftext_set, set)
+    assert sorted(ftext_set) == [u'NULL', 'val02', 'val1', 'val2']
+    assert tbl.get_max_field_value('ftext') == 'val2'
+    assert tbl.get_max_field_value('ftext', True) == 'val02'
+    assert tbl.get_max_field_value_length('ftext') == 5
+
+
+def test_tableobj_single_integer_field_methods(testdatabase):
+    # test table object methods
+    tbl = table.TableObj(testdatabase.fc1)
+    fint_set = tbl.get_field_value_set('fint')
+    assert isinstance(fint_set, set)
+    assert tbl.get_field_value_set('fint') == set([4, 5, 7, 10, u'NULL'])
+    assert tbl.get_max_field_value('fint') == 10
+    assert tbl.get_max_field_value_length('fint') == 2
+
+
+def test_tableobj_multi_field_methods(testdatabase):
+    # test table object methods
+    tbl = table.TableObj(testdatabase.fc1)
+    multi_field = tbl.get_multiple_field_value_set(['ftext', 'fint'])
+    assert isinstance(multi_field, set)
+    assert sorted(multi_field) == [u'NULL:5', u'val02:7', u'val1:10', u'val1:4', u'val1:NULL', u'val2:5', u'val2:7']
+   
+    
+
+def test_tableobj_compare_methods(testdatabase):
+    # test table object compare methods
+    tbl = table.TableObj(testdatabase.fc1)
+    result = tbl.compare_field_values_to_domain('fint', testdatabase.gdb, "fint_range")
+    result.match.sort()
+    assert result.match == [4, 5, 7, 10]
+    assert result.unmatched == []
+
+    result = tbl.compare_field_values_to_domain('ftext', testdatabase.gdb, "ftext_coded")
+    result.match.sort()
+    result.unmatched.sort()
+    assert result.match == ['val1', 'val2']
+    assert result.unmatched == ['NULL', 'val02']
+
+
+def test_table_fc_methods(testdatabase):
+    # test non-object table methods
+    #table.compare_schema(testdata.fc, testdata.fc2)
+    assert True
+