diff --git a/pyaccuwage/__init__.py b/pyaccuwage/__init__.py index 810de18..a6775be 100644 --- a/pyaccuwage/__init__.py +++ b/pyaccuwage/__init__.py @@ -1,9 +1,8 @@ -try: - from collections import Callable -except: - from typing import Callable # Python 3.10+ +from .record import * +from .reader import RecordReader +import collections -VERSION = (0, 2025, 0) +VERSION = (0, 2012, 0) RECORD_TYPES = [ 'SubmitterRecord', @@ -15,76 +14,91 @@ RECORD_TYPES = [ 'OptionalTotalRecord', 'StateTotalRecord', 'FinalRecord' -] + ] + +def test(): + from . import record, model + from .fields import ValidationError + for rname in RECORD_TYPES: + inst = record.__dict__[rname]() + try: + output_length = len(inst.output()) + except ValidationError as e: + print(e.msg, type(inst), inst.record_identifier) + continue + + print(type(inst), inst.record_identifier, output_length) -def get_record_types(): +def test_dump(): + import record, io + records = [ + record.SubmitterRecord(), + record.EmployerRecord(), + record.EmployeeWageRecord(), + ] + out = io.BytesIO() + dump(records, out) + return out + + +def test_record_order(): + from . import record + records = [ + record.SubmitterRecord(), + record.EmployerRecord(), + record.EmployeeWageRecord(), + record.TotalRecord(), + record.FinalRecord(), + ] + validate_record_order(records) + + +def test_load(fp): + return load(fp) + +def load(fp): + # BUILD LIST OF RECORD TYPES from . import record types = {} for r in RECORD_TYPES: klass = record.__dict__[r] types[klass.record_identifier] = klass - return types - - -def load(fp, record_types): - distinct_identifier_lengths = set([len(record_types[k].record_identifier) for k in record_types]) - assert(len(distinct_identifier_lengths) == 1) - ident_length = list(distinct_identifier_lengths)[0] - - # Add aliases for the record types based on their record_identifier since that's all - # we have to work with with the e1099 data. - record_types_by_ident = {} - for k in record_types: - record_type = record_types[k] - record_identifier = record_type.record_identifier - record_types_by_ident[record_identifier] = record_type # PARSE DATA INTO RECORDS AND YIELD THEM - while True: - record_ident = fp.read(ident_length) - if not record_ident: - break - if record_ident in record_types_by_ident: - record = record_types_by_ident[record_ident]() + while fp.tell() < fp.len: + record_ident = fp.read(2) + if record_ident in types: + record = types[record_ident]() record.read(fp) yield record - -def loads(s, record_types=get_record_types()): +def loads(s): import io fp = io.BytesIO(s) - return load(fp, record_types) + return load(fp) -def dump(fp, records, delim=None): - if type(delim) is str: - delim = delim.encode('ascii') +def dump(records, fp): for r in records: fp.write(r.output()) - if delim: - fp.write(delim) - -def dumps(records, delim=None, skip_validation=False): +def dumps(records): import io fp = io.BytesIO() - if not skip_validation: - for record in records: - record.validate() - dump(fp, records, delim=delim) + dump(records, fp) fp.seek(0) return fp.read() - def json_dumps(records): import json + from . import model import decimal class JSONEncoder(json.JSONEncoder): def default(self, o): - if hasattr(o, 'toJSON') and isinstance(getattr(o, 'toJSON'), Callable): + if hasattr(o, 'toJSON') and isinstance(getattr(o, 'toJSON'), collections.Callable): return o.toJSON() if type(o) is bytes: @@ -95,76 +109,37 @@ def json_dumps(records): return super(JSONEncoder, self).default(o) - return json.dumps(list(records), cls=JSONEncoder, indent=2) + return json.dumps(records, cls=JSONEncoder, indent=2) -def json_dump(fp, records): - fp.write(json_dumps(records)) - - -def json_loads(s, record_types): +def json_loads(s, record_classes): import json from . import fields import decimal + import re - if not isinstance(record_types, dict): - record_types = dict([ (x.__name__, x) for x in record_types]) + if not isinstance(record_classes, dict): + record_classes = dict([ (x.__class__.__name__, x) for x in record_classes]) def object_hook(o): if '__class__' in o: klass = o['__class__'] - if klass in record_types: - record = record_types[klass]() - record.fromJSON(o) - return record + + if klass in record_classes: + return record_classes[klass]().fromJSON(o) + elif hasattr(fields, klass): return getattr(fields, klass)().fromJSON(o) + return o + #print "OBJECTHOOK", str(o) + #return {'object_hook':str(o)} + #def default(self, o): + # return super(JSONDecoder, self).default(o) + return json.loads(s, parse_float=decimal.Decimal, object_hook=object_hook) -def json_load(fp, record_types): - return json_loads(fp.read(), record_types) - -def text_dump(fp, records): - for r in records: - fp.write(r.output(format='text').encode('ascii')) - - -def text_dumps(records): - import io - fp = io.BytesIO() - text_dump(fp, records) - fp.seek(0) - return fp.read() - - -def text_load(fp, record_classes): - records = [] - current_record = None - - if not isinstance(record_classes, dict): - record_classes = dict([ (x.__name__, x) for x in record_classes]) - - while True: #fp.readable(): - line = fp.readline().decode('ascii') - if not line: - break - if line.startswith('---'): - record_name = line.strip('---').strip() - current_record = record_classes[record_name]() - records.append(current_record) - elif ':' in line: - field, value = [x.strip() for x in line.split(':')] - current_record.set_field_value(field, value) - return records - -def text_loads(s, record_classes): - import io - fp = io.BytesIO(s) - return text_load(fp, record_classes) - - # THIS WAS IN CONTROLLER, BUT UNLESS WE # REALLY NEED A CONTROLLER CLASS, IT'S SIMPLER # TO JUST KEEP IT IN HERE. @@ -176,7 +151,7 @@ def validate_required_records(records): klass = record.__dict__[r] if klass.required: req_types.append(klass.__name__) - + while req_types: req = req_types[0] if req not in types: @@ -185,11 +160,10 @@ def validate_required_records(records): else: req_types.remove(req) - def validate_record_order(records): from . import record from .fields import ValidationError - + # 1st record must be SubmitterRecord if not isinstance(records[0], record.SubmitterRecord): raise ValidationError("First record must be SubmitterRecord") @@ -235,10 +209,15 @@ def test_unique_fields(): r1 = EmployeeWageRecord() r1.employee_first_name.value = "John Johnson" - + r2 = EmployeeWageRecord() print('r1:', r1.employee_first_name.value, r1.employee_first_name, r1.employee_first_name.creation_counter) print('r2:', r2.employee_first_name.value, r2.employee_first_name, r2.employee_first_name.creation_counter) - + if r1.employee_first_name.value == r2.employee_first_name.value: raise ValidationError("Horrible problem involving shared values across records") + +#def state_postal_code(state_abbr): +# import enums +# return enums.state_postal_numeric[ state_abbr.upper() ] + diff --git a/pyaccuwage/enums.py b/pyaccuwage/enums.py index 66a8722..b5c3c09 100644 --- a/pyaccuwage/enums.py +++ b/pyaccuwage/enums.py @@ -1,340 +1,338 @@ state_postal_numeric = { - 'AL': 1, - 'AK': 2, - 'AZ': 4, - 'AR': 5, - 'CA': 6, - 'CO': 8, - 'CT': 9, - 'DE': 10, - 'DC': 11, - 'FL': 12, - 'GA': 13, - 'HI': 15, - 'ID': 16, - 'IL': 17, - 'IN': 18, - 'IA': 19, - 'KS': 20, - 'KY': 21, - 'LA': 22, - 'ME': 23, - 'MD': 24, - 'MA': 25, - 'MI': 26, - 'MN': 27, - 'MS': 28, - 'MO': 29, - 'MT': 30, - 'NE': 31, - 'NV': 32, - 'NH': 33, - 'NJ': 34, - 'NM': 35, - 'NY': 36, - 'NC': 37, - 'ND': 38, - 'OH': 39, - 'OK': 40, - 'OR': 41, - 'PA': 42, - 'RI': 44, - 'SC': 45, - 'SD': 46, - 'TN': 47, - 'TX': 48, - 'UT': 49, - 'VT': 50, - 'VA': 51, - 'WA': 53, - 'WV': 54, - 'WI': 55, - 'WY': 56, + 'AL': 1, + 'AK': 2, + 'AZ': 4, + 'AR': 5, + 'CA': 6, + 'CO': 8, + 'CT': 9, + 'DE': 10, + 'DC': 11, + 'FL': 12, + 'GA': 13, + 'HI': 15, + 'ID': 16, + 'IL': 17, + 'IN': 18, + 'IA': 19, + 'KS': 20, + 'KY': 21, + 'LA': 22, + 'ME': 23, + 'MD': 24, + 'MA': 25, + 'MI': 26, + 'MN': 27, + 'MS': 28, + 'MO': 29, + 'MT': 30, + 'NE': 31, + 'NV': 32, + 'NH': 33, + 'NJ': 34, + 'NM': 35, + 'NY': 36, + 'NC': 37, + 'ND': 38, + 'OH': 39, + 'OK': 40, + 'OR': 41, + 'PA': 42, + 'RI': 44, + 'SC': 45, + 'SD': 46, + 'TN': 47, + 'TX': 48, + 'UT': 49, + 'VT': 50, + 'VA': 51, + 'WA': 53, + 'WV': 54, + 'WI': 55, + 'WY': 56, } countries = ( - ('AF', 'Afghanistan'), - ('AX', 'Aland Islands'), - ('AL', 'Albania'), - ('DZ', 'Algeria'), - ('AS', 'American Samoa'), - ('AD', 'Andorra'), - ('AO', 'Angola'), - ('AI', 'Anguilla'), - ('AQ', 'Antarctica'), - ('AG', 'Antigua and Barbuda'), - ('AR', 'Argentina'), - ('AM', 'Armenia'), - ('AW', 'Aruba'), - ('AU', 'Australia'), - ('AT', 'Austria'), - ('AZ', 'Azerbaijan'), - ('BS', 'Bahamas'), - ('BH', 'Bahrain'), - ('BD', 'Bangladesh'), - ('BB', 'Barbados'), - ('BY', 'Belarus'), - ('BE', 'Belgium'), - ('BZ', 'Belize'), - ('BJ', 'Benin'), - ('BM', 'Bermuda'), - ('BT', 'Bhutan'), - ('BO', 'Bolivia, Plurinational State of'), - ('BQ', 'Bonaire, Saint Eustatius and Saba'), - ('BA', 'Bosnia and Herzegovina'), - ('BW', 'Botswana'), - ('BV', 'Bouvet Island'), - ('BR', 'Brazil'), - ('IO', 'British Indian Ocean Territory'), - ('BN', 'Brunei Darussalam'), - ('BG', 'Bulgaria'), - ('BF', 'Burkina Faso'), - ('BI', 'Burundi'), - ('KH', 'Cambodia'), - ('CM', 'Cameroon'), - ('CA', 'Canada'), - ('CV', 'Cape Verde'), - ('KY', 'Cayman Islands'), - ('CF', 'Central African Republic'), - ('TD', 'Chad'), - ('CL', 'Chile'), - ('CN', 'China'), - ('CX', 'Christmas Island'), - ('CC', 'Cocos (Keeling) Islands'), - ('CO', 'Colombia'), - ('KM', 'Comoros'), - ('CG', 'Congo'), - ('CD', 'Congo, The Democratic Republic of the'), - ('CK', 'Cook Islands'), - ('CR', 'Costa Rica'), - ('CI', "Cote D'ivoire"), - ('HR', 'Croatia'), - ('CU', 'Cuba'), - ('CW', 'Curacao'), - ('CY', 'Cyprus'), - ('CZ', 'Czech Republic'), - ('DK', 'Denmark'), - ('DJ', 'Djibouti'), - ('DM', 'Dominica'), - ('DO', 'Dominican Republic'), - ('EC', 'Ecuador'), - ('EG', 'Egypt'), - ('SV', 'El Salvador'), - ('GQ', 'Equatorial Guinea'), - ('ER', 'Eritrea'), - ('EE', 'Estonia'), - ('ET', 'Ethiopia'), - ('FK', 'Falkland Islands (Malvinas)'), - ('FO', 'Faroe Islands'), - ('FJ', 'Fiji'), - ('FI', 'Finland'), - ('FR', 'France'), - ('GF', 'French Guiana'), - ('PF', 'French Polynesia'), - ('TF', 'French Southern Territories'), - ('GA', 'Gabon'), - ('GM', 'Gambia'), - ('GE', 'Georgia'), - ('DE', 'Germany'), - ('GH', 'Ghana'), - ('GI', 'Gibraltar'), - ('GR', 'Greece'), - ('GL', 'Greenland'), - ('GD', 'Grenada'), - ('GP', 'Guadeloupe'), - ('GU', 'Guam'), - ('GT', 'Guatemala'), - ('GG', 'Guernsey'), - ('GN', 'Guinea'), - ('GW', 'Guinea-Bissau'), - ('GY', 'Guyana'), - ('HT', 'Haiti'), - ('HM', 'Heard Island and McDonald Islands'), - ('VA', 'Holy See (Vatican City State)'), - ('HN', 'Honduras'), - ('HK', 'Hong Kong'), - ('HU', 'Hungary'), - ('IS', 'Iceland'), - ('IN', 'India'), - ('ID', 'Indonesia'), - ('IR', 'Iran, Islamic Republic of'), - ('IQ', 'Iraq'), - ('IE', 'Ireland'), - ('IM', 'Isle of Man'), - ('IL', 'Israel'), - ('IT', 'Italy'), - ('JM', 'Jamaica'), - ('JP', 'Japan'), - ('JE', 'Jersey'), - ('JO', 'Jordan'), - ('KZ', 'Kazakhstan'), - ('KE', 'Kenya'), - ('KI', 'Kiribati'), - ('KP', "Korea, Democratic People's Republic of"), - ('KR', 'Korea, Republic of'), - ('KW', 'Kuwait'), - ('KG', 'Kyrgyzstan'), - ('LA', "Lao People's Democratic Republic"), - ('LV', 'Latvia'), - ('LB', 'Lebanon'), - ('LS', 'Lesotho'), - ('LR', 'Liberia'), - ('LY', 'Libyan Arab Jamahiriya'), - ('LI', 'Liechtenstein'), - ('LT', 'Lithuania'), - ('LU', 'Luxembourg'), - ('MO', 'Macao'), - ('MK', 'Macedonia, The Former Yugoslav Republic of'), - ('MG', 'Madagascar'), - ('MW', 'Malawi'), - ('MY', 'Malaysia'), - ('MV', 'Maldives'), - ('ML', 'Mali'), - ('MT', 'Malta'), - ('MH', 'Marshall Islands'), - ('MQ', 'Martinique'), - ('MR', 'Mauritania'), - ('MU', 'Mauritius'), - ('YT', 'Mayotte'), - ('MX', 'Mexico'), - ('FM', 'Micronesia, Federated States of'), - ('MD', 'Moldova, Republic of'), - ('MC', 'Monaco'), - ('MN', 'Mongolia'), - ('ME', 'Montenegro'), - ('MS', 'Montserrat'), - ('MA', 'Morocco'), - ('MZ', 'Mozambique'), - ('MM', 'Myanmar'), - ('NA', 'Namibia'), - ('NR', 'Nauru'), - ('NP', 'Nepal'), - ('NL', 'Netherlands'), - ('NC', 'New Caledonia'), - ('NZ', 'New Zealand'), - ('NI', 'Nicaragua'), - ('NE', 'Niger'), - ('NG', 'Nigeria'), - ('NU', 'Niue'), - ('NF', 'Norfolk Island'), - ('MP', 'Northern Mariana Islands'), - ('NO', 'Norway'), - ('OM', 'Oman'), - ('PK', 'Pakistan'), - ('PW', 'Palau'), - ('PS', 'Palestinian Territory, Occupied'), - ('PA', 'Panama'), - ('PG', 'Papua New Guinea'), - ('PY', 'Paraguay'), - ('PE', 'Peru'), - ('PH', 'Philippines'), - ('PN', 'Pitcairn'), - ('PL', 'Poland'), - ('PT', 'Portugal'), - ('PR', 'Puerto Rico'), - ('QA', 'Qatar'), - ('RE', 'Reunion'), - ('RO', 'Romania'), - ('RU', 'Russian Federation'), - ('RW', 'Rwanda'), - ('BL', 'Saint Barthelemy'), - ('SH', 'Saint Helena, Ascension and Tristan Da Cunha'), - ('KN', 'Saint Kitts and Nevis'), - ('LC', 'Saint Lucia'), - ('MF', 'Saint Martin (French Part)'), - ('PM', 'Saint Pierre and Miquelon'), - ('VC', 'Saint Vincent and the Grenadines'), - ('WS', 'Samoa'), - ('SM', 'San Marino'), - ('ST', 'Sao Tome and Principe'), - ('SA', 'Saudi Arabia'), - ('SN', 'Senegal'), - ('RS', 'Serbia'), - ('SC', 'Seychelles'), - ('SL', 'Sierra Leone'), - ('SG', 'Singapore'), - ('SX', 'Sint Maarten (Dutch Part)'), - ('SK', 'Slovakia'), - ('SI', 'Slovenia'), - ('SB', 'Solomon Islands'), - ('SO', 'Somalia'), - ('ZA', 'South Africa'), - ('GS', 'South Georgia and the South Sandwich Islands'), - ('ES', 'Spain'), - ('LK', 'Sri Lanka'), - ('SD', 'Sudan'), - ('SR', 'Suriname'), - ('SJ', 'Svalbard and Jan Mayen'), - ('SZ', 'Swaziland'), - ('SE', 'Sweden'), - ('CH', 'Switzerland'), - ('SY', 'Syrian Arab Republic'), - ('TW', 'Taiwan, Province of China'), - ('TJ', 'Tajikistan'), - ('TZ', 'Tanzania, United Republic of'), - ('TH', 'Thailand'), - ('TL', 'Timor-Leste'), - ('TG', 'Togo'), - ('TK', 'Tokelau'), - ('TO', 'Tonga'), - ('TT', 'Trinidad and Tobago'), - ('TN', 'Tunisia'), - ('TR', 'Turkey'), - ('TM', 'Turkmenistan'), - ('TC', 'Turks and Caicos Islands'), - ('TV', 'Tuvalu'), - ('UG', 'Uganda'), - ('UA', 'Ukraine'), - ('AE', 'United Arab Emirates'), - ('GB', 'United Kingdom'), - ('US', 'United States'), - ('UM', 'United States Minor Outlying Islands'), - ('UY', 'Uruguay'), - ('UZ', 'Uzbekistan'), - ('VU', 'Vanuatu'), - ('VE', 'Venezuela, Bolivarian Republic of'), - ('VN', 'Viet Nam'), - ('VG', 'Virgin Islands, British'), - ('VI', 'Virgin Islands, U.S.'), - ('WF', 'Wallis and Futuna'), - ('EH', 'Western Sahara'), - ('YE', 'Yemen'), - ('ZM', 'Zambia'), - ('ZW', 'Zimbabwe'), - ) + ('AF', 'Afghanistan'), + ('AX', 'Aland Islands'), + ('AL', 'Albania'), + ('DZ', 'Algeria'), + ('AS', 'American Samoa'), + ('AD', 'Andorra'), + ('AO', 'Angola'), + ('AI', 'Anguilla'), + ('AQ', 'Antarctica'), + ('AG', 'Antigua and Barbuda'), + ('AR', 'Argentina'), + ('AM', 'Armenia'), + ('AW', 'Aruba'), + ('AU', 'Australia'), + ('AT', 'Austria'), + ('AZ', 'Azerbaijan'), + ('BS', 'Bahamas'), + ('BH', 'Bahrain'), + ('BD', 'Bangladesh'), + ('BB', 'Barbados'), + ('BY', 'Belarus'), + ('BE', 'Belgium'), + ('BZ', 'Belize'), + ('BJ', 'Benin'), + ('BM', 'Bermuda'), + ('BT', 'Bhutan'), + ('BO', 'Bolivia, Plurinational State of'), + ('BQ', 'Bonaire, Saint Eustatius and Saba'), + ('BA', 'Bosnia and Herzegovina'), + ('BW', 'Botswana'), + ('BV', 'Bouvet Island'), + ('BR', 'Brazil'), + ('IO', 'British Indian Ocean Territory'), + ('BN', 'Brunei Darussalam'), + ('BG', 'Bulgaria'), + ('BF', 'Burkina Faso'), + ('BI', 'Burundi'), + ('KH', 'Cambodia'), + ('CM', 'Cameroon'), + ('CA', 'Canada'), + ('CV', 'Cape Verde'), + ('KY', 'Cayman Islands'), + ('CF', 'Central African Republic'), + ('TD', 'Chad'), + ('CL', 'Chile'), + ('CN', 'China'), + ('CX', 'Christmas Island'), + ('CC', 'Cocos (Keeling) Islands'), + ('CO', 'Colombia'), + ('KM', 'Comoros'), + ('CG', 'Congo'), + ('CD', 'Congo, The Democratic Republic of the'), + ('CK', 'Cook Islands'), + ('CR', 'Costa Rica'), + ('CI', "Cote D'ivoire"), + ('HR', 'Croatia'), + ('CU', 'Cuba'), + ('CW', 'Curacao'), + ('CY', 'Cyprus'), + ('CZ', 'Czech Republic'), + ('DK', 'Denmark'), + ('DJ', 'Djibouti'), + ('DM', 'Dominica'), + ('DO', 'Dominican Republic'), + ('EC', 'Ecuador'), + ('EG', 'Egypt'), + ('SV', 'El Salvador'), + ('GQ', 'Equatorial Guinea'), + ('ER', 'Eritrea'), + ('EE', 'Estonia'), + ('ET', 'Ethiopia'), + ('FK', 'Falkland Islands (Malvinas)'), + ('FO', 'Faroe Islands'), + ('FJ', 'Fiji'), + ('FI', 'Finland'), + ('FR', 'France'), + ('GF', 'French Guiana'), + ('PF', 'French Polynesia'), + ('TF', 'French Southern Territories'), + ('GA', 'Gabon'), + ('GM', 'Gambia'), + ('GE', 'Georgia'), + ('DE', 'Germany'), + ('GH', 'Ghana'), + ('GI', 'Gibraltar'), + ('GR', 'Greece'), + ('GL', 'Greenland'), + ('GD', 'Grenada'), + ('GP', 'Guadeloupe'), + ('GU', 'Guam'), + ('GT', 'Guatemala'), + ('GG', 'Guernsey'), + ('GN', 'Guinea'), + ('GW', 'Guinea-Bissau'), + ('GY', 'Guyana'), + ('HT', 'Haiti'), + ('HM', 'Heard Island and McDonald Islands'), + ('VA', 'Holy See (Vatican City State)'), + ('HN', 'Honduras'), + ('HK', 'Hong Kong'), + ('HU', 'Hungary'), + ('IS', 'Iceland'), + ('IN', 'India'), + ('ID', 'Indonesia'), + ('IR', 'Iran, Islamic Republic of'), + ('IQ', 'Iraq'), + ('IE', 'Ireland'), + ('IM', 'Isle of Man'), + ('IL', 'Israel'), + ('IT', 'Italy'), + ('JM', 'Jamaica'), + ('JP', 'Japan'), + ('JE', 'Jersey'), + ('JO', 'Jordan'), + ('KZ', 'Kazakhstan'), + ('KE', 'Kenya'), + ('KI', 'Kiribati'), + ('KP', "Korea, Democratic People's Republic of"), + ('KR', 'Korea, Republic of'), + ('KW', 'Kuwait'), + ('KG', 'Kyrgyzstan'), + ('LA', "Lao People's Democratic Republic"), + ('LV', 'Latvia'), + ('LB', 'Lebanon'), + ('LS', 'Lesotho'), + ('LR', 'Liberia'), + ('LY', 'Libyan Arab Jamahiriya'), + ('LI', 'Liechtenstein'), + ('LT', 'Lithuania'), + ('LU', 'Luxembourg'), + ('MO', 'Macao'), + ('MK', 'Macedonia, The Former Yugoslav Republic of'), + ('MG', 'Madagascar'), + ('MW', 'Malawi'), + ('MY', 'Malaysia'), + ('MV', 'Maldives'), + ('ML', 'Mali'), + ('MT', 'Malta'), + ('MH', 'Marshall Islands'), + ('MQ', 'Martinique'), + ('MR', 'Mauritania'), + ('MU', 'Mauritius'), + ('YT', 'Mayotte'), + ('MX', 'Mexico'), + ('FM', 'Micronesia, Federated States of'), + ('MD', 'Moldova, Republic of'), + ('MC', 'Monaco'), + ('MN', 'Mongolia'), + ('ME', 'Montenegro'), + ('MS', 'Montserrat'), + ('MA', 'Morocco'), + ('MZ', 'Mozambique'), + ('MM', 'Myanmar'), + ('NA', 'Namibia'), + ('NR', 'Nauru'), + ('NP', 'Nepal'), + ('NL', 'Netherlands'), + ('NC', 'New Caledonia'), + ('NZ', 'New Zealand'), + ('NI', 'Nicaragua'), + ('NE', 'Niger'), + ('NG', 'Nigeria'), + ('NU', 'Niue'), + ('NF', 'Norfolk Island'), + ('MP', 'Northern Mariana Islands'), + ('NO', 'Norway'), + ('OM', 'Oman'), + ('PK', 'Pakistan'), + ('PW', 'Palau'), + ('PS', 'Palestinian Territory, Occupied'), + ('PA', 'Panama'), + ('PG', 'Papua New Guinea'), + ('PY', 'Paraguay'), + ('PE', 'Peru'), + ('PH', 'Philippines'), + ('PN', 'Pitcairn'), + ('PL', 'Poland'), + ('PT', 'Portugal'), + ('PR', 'Puerto Rico'), + ('QA', 'Qatar'), + ('RE', 'Reunion'), + ('RO', 'Romania'), + ('RU', 'Russian Federation'), + ('RW', 'Rwanda'), + ('BL', 'Saint Barthelemy'), + ('SH', 'Saint Helena, Ascension and Tristan Da Cunha'), + ('KN', 'Saint Kitts and Nevis'), + ('LC', 'Saint Lucia'), + ('MF', 'Saint Martin (French Part)'), + ('PM', 'Saint Pierre and Miquelon'), + ('VC', 'Saint Vincent and the Grenadines'), + ('WS', 'Samoa'), + ('SM', 'San Marino'), + ('ST', 'Sao Tome and Principe'), + ('SA', 'Saudi Arabia'), + ('SN', 'Senegal'), + ('RS', 'Serbia'), + ('SC', 'Seychelles'), + ('SL', 'Sierra Leone'), + ('SG', 'Singapore'), + ('SX', 'Sint Maarten (Dutch Part)'), + ('SK', 'Slovakia'), + ('SI', 'Slovenia'), + ('SB', 'Solomon Islands'), + ('SO', 'Somalia'), + ('ZA', 'South Africa'), + ('GS', 'South Georgia and the South Sandwich Islands'), + ('ES', 'Spain'), + ('LK', 'Sri Lanka'), + ('SD', 'Sudan'), + ('SR', 'Suriname'), + ('SJ', 'Svalbard and Jan Mayen'), + ('SZ', 'Swaziland'), + ('SE', 'Sweden'), + ('CH', 'Switzerland'), + ('SY', 'Syrian Arab Republic'), + ('TW', 'Taiwan, Province of China'), + ('TJ', 'Tajikistan'), + ('TZ', 'Tanzania, United Republic of'), + ('TH', 'Thailand'), + ('TL', 'Timor-Leste'), + ('TG', 'Togo'), + ('TK', 'Tokelau'), + ('TO', 'Tonga'), + ('TT', 'Trinidad and Tobago'), + ('TN', 'Tunisia'), + ('TR', 'Turkey'), + ('TM', 'Turkmenistan'), + ('TC', 'Turks and Caicos Islands'), + ('TV', 'Tuvalu'), + ('UG', 'Uganda'), + ('UA', 'Ukraine'), + ('AE', 'United Arab Emirates'), + ('GB', 'United Kingdom'), + ('US', 'United States'), + ('UM', 'United States Minor Outlying Islands'), + ('UY', 'Uruguay'), + ('UZ', 'Uzbekistan'), + ('VU', 'Vanuatu'), + ('VE', 'Venezuela, Bolivarian Republic of'), + ('VN', 'Viet Nam'), + ('VG', 'Virgin Islands, British'), + ('VI', 'Virgin Islands, U.S.'), + ('WF', 'Wallis and Futuna'), + ('EH', 'Western Sahara'), + ('YE', 'Yemen'), + ('ZM', 'Zambia'), + ('ZW', 'Zimbabwe')) employer_types = ( - ('F','Federal Government'), - ('S','State and Local Governmental Employer'), - ('T','Tax Exempt Employer'), - ('Y','State and Local Tax Exempt Employer'), - ('N','None Apply'), - ) + ('F','Federal Government'), + ('S','State and Local Governmental Employer'), + ('T','Tax Exempt Employer'), + ('Y','State and Local Tax Exempt Employer'), + ('N','None Apply'), + ) employment_codes = ( - ('A', 'Agriculture'), - ('H', 'Household'), - ('M', 'Military'), - ('Q', 'Medicare Qualified Government Employee'), - ('X', 'Railroad'), - ('F', 'Regular'), - ('R', 'Regular (all others)'), - ) + ('A', 'Agriculture'), + ('H', 'Household'), + ('M', 'Military'), + ('Q', 'Medicare Qualified Government Employee'), + ('X', 'Railroad'), + ('F', 'Regular'), + ('R', 'Regular (all others)'), + ) tax_jurisdiction_codes = ( - (' ', 'W-2'), - ('V', 'Virgin Islands'), - ('G', 'Guam'), - ('S', 'American Samoa'), - ('N', 'Northern Mariana Islands'), - ('P', 'Puerto Rico'), - ) + ('V', 'Virgin Islands'), + ('G', 'Guam'), + ('S', 'American Samoa'), + ('N', 'Northern Mariana Islands'), + ('P', 'Puerto Rico'), + ) tax_type_codes = ( - ('C', 'City Income Tax'), - ('D', 'Country Income Tax'), - ('E', 'School District Income Tax'), - ('F', 'Other Income Tax'), - ) + ('C', 'City Income Tax'), + ('D', 'Country Income Tax'), + ('E', 'School District Income Tax'), + ('F', 'Other Income Tax'), + ) diff --git a/pyaccuwage/fields.py b/pyaccuwage/fields.py index 8291d63..94147a8 100644 --- a/pyaccuwage/fields.py +++ b/pyaccuwage/fields.py @@ -1,11 +1,7 @@ import decimal, datetime import inspect -from six import string_types from . import enums -def is_blank_space(val): - return len(val.strip()) == 0 - class ValidationError(Exception): def __init__(self, msg, field=None): self.msg = msg @@ -20,26 +16,22 @@ class ValidationError(Exception): class Field(object): creation_counter = 0 - is_read_only = False - _value = None - def __init__(self, name=None, min_length=0, max_length=0, blank=False, required=True, uppercase=True, creation_counter=None): + def __init__(self, name=None, max_length=0, required=True, uppercase=True, creation_counter=None): self.name = name self._value = None self._orig_value = None - self.min_length = min_length self.max_length = max_length - self.blank = blank self.required = required self.uppercase = uppercase self.creation_counter = creation_counter or Field.creation_counter Field.creation_counter += 1 def validate(self): - raise NotImplementedError + raise NotImplemented def get_data(self): - raise NotImplementedError + raise NotImplemented def __setvalue(self, value): self._value = value @@ -84,7 +76,7 @@ class Field(object): required=o['required'], ) - if isinstance(o['value'], str) and re.match(r'^\d*\.\d*$', o['value']): + if isinstance(o['value'], str) and re.match('^\d*\.\d*$', o['value']): o['value'] = decimal.Decimal(o['value']) self.value = o['value'] @@ -98,10 +90,14 @@ class Field(object): wrapper = textwrap.TextWrapper(replace_whitespace=False, drop_whitespace=False) wrapper.width = 100 value = wrapper.wrap(value) + #value = textwrap.wrap(value, 100) + #print value value = list([(" " * 9) + ('"' + x + '"') for x in value]) - value.append(" " * 10 + ('_' * 10) * int(wrapper.width / 10)) - value.append(" " * 10 + ('0123456789') * int(wrapper.width / 10)) - value.append(" " * 10 + ''.join(([str(x) + (' ' * 9) for x in range(int(wrapper.width / 10))]))) + #value[0] = '"' + value[0] + '"' + value.append(" " * 10 + ('_' * 10) * (wrapper.width / 10)) + value.append(" " * 10 + ('0123456789') * (wrapper.width / 10)) + value.append(" " * 10 + ''.join(([str(x) + (' ' * 9) for x in range(wrapper.width / 10 )]))) + #value.append((" " * 59) + map(lambda x:("%x" % x), range(16)) start = counter['c'] counter['c'] += len(self._orig_value or self.value) @@ -121,17 +117,11 @@ class TextField(Field): def validate(self): if self.value is None and self.required: raise ValidationError("value required", field=self) - data = self.get_data() - if len(data) > self.max_length: + if len(self.get_data()) > self.max_length: raise ValidationError("value is too long", field=self) - stripped_data_length = len(data.strip()) - if stripped_data_length < self.min_length: - raise ValidationError("value is too short", field=self) - if stripped_data_length == 0 and (not self.blank and self.required): - raise ValidationError("field cannot be blank", field=self) def get_data(self): - value = str(self.value or '').encode('ascii') or b'' + value = str(self.value).encode('ascii') or b'' if self.uppercase: value = value.upper() return value.ljust(self.max_length)[:self.max_length] @@ -152,10 +142,11 @@ class TextField(Field): class StateField(TextField): def __init__(self, name=None, required=True, use_numeric=False, max_length=2): - super(StateField, self).__init__(name=name, max_length=max_length, required=required) + super(StateField, self).__init__(name=name, max_length=2, required=required) self.use_numeric = use_numeric def get_data(self): + # value = str(self.value or 'XX').encode('ascii') or b'' value = str(self.value or 'XX') if value.strip() and self.use_numeric: postcode = enums.state_postal_numeric[value.upper()] @@ -177,10 +168,9 @@ class StateField(TextField): else: self.value = s - class EmailField(TextField): def __init__(self, name=None, required=True, max_length=None): - super(EmailField, self).__init__(name=name, max_length=max_length, + return super(EmailField, self).__init__(name=name, max_length=max_length, required=required, uppercase=False) class IntegerField(TextField): @@ -197,29 +187,21 @@ class IntegerField(TextField): return value.zfill(self.max_length)[:self.max_length] def parse(self, s): - if not is_blank_space(s): - self.value = int(s) - else: - self.value = 0 + self.value = int(s) class StaticField(TextField): - def __init__(self, name=None, required=True, value=None, uppercase=False): - super(StaticField, self).__init__(name=name, - required=required, - max_length=len(value), - uppercase=uppercase) - self._static_value = value + def __init__(self, name=None, required=True, value=None): + super(StaticField, self).__init__(name=name, required=required, + max_length=len(value)) self._value = value def parse(self, s): pass class BlankField(TextField): - is_read_only = True - def __init__(self, name=None, max_length=0, required=False): - super(BlankField, self).__init__(name=name, max_length=max_length, required=required, uppercase=False) + super(TextField, self).__init__(name=name, max_length=max_length, required=required, uppercase=False) def get_data(self): return b' ' * self.max_length @@ -227,23 +209,13 @@ class BlankField(TextField): def parse(self, s): pass - def validate(self): - if len(self.get_data()) != self.max_length: - raise ValidationError("blank field did not match expected length", field=self) - - class ZeroField(BlankField): - is_read_only = True - def get_data(self): return b'0' * self.max_length - class CRLFField(TextField): - is_read_only = True - def __init__(self, name=None, required=False): - super(CRLFField, self).__init__(name=name, max_length=2, required=required, uppercase=False) + super(TextField, self).__init__(name=name, max_length=2, required=required, uppercase=False) def __setvalue(self, value): self._value = value @@ -259,7 +231,6 @@ class CRLFField(TextField): def parse(self, s): self.value = s - class BooleanField(Field): def __init__(self, name=None, required=True, value=None): super(BooleanField, self).__init__(name=name, required=required, max_length=1) @@ -291,27 +262,12 @@ class MoneyField(Field): return formatted[:self.max_length] def parse(self, s): - if not is_blank_space(s): - self.value = decimal.Decimal(s) * decimal.Decimal('0.01') - else: - self.value = decimal.Decimal(0.0) + self.value = decimal.Decimal(s) * decimal.Decimal('0.01') - def __setvalue(self, value): - new_value = value - if isinstance(new_value, string_types): - new_value = decimal.Decimal(new_value or '0') - if '.' not in value: # must be cents? - new_value *= decimal.Decimal('100.') - self._value = new_value - - def __getvalue(self): - return self._value - - value = property(__getvalue, __setvalue) class DateField(TextField): def __init__(self, name=None, required=True, value=None): - super(DateField, self).__init__(name=name, required=required, max_length=8) + super(TextField, self).__init__(name=name, required=required, max_length=8) if value: self.value = value @@ -342,7 +298,8 @@ class DateField(TextField): class MonthYearField(TextField): def __init__(self, name=None, required=True, value=None): - super(MonthYearField, self).__init__(name=name, required=required, max_length=6) + super(TextField, self).__init__(name=name, required=required, max_length=6) + if value: self.value = value @@ -369,3 +326,4 @@ class MonthYearField(TextField): return self._value value = property(__getvalue, __setvalue) + diff --git a/pyaccuwage/model.py b/pyaccuwage/model.py index c950055..ae5f9e1 100644 --- a/pyaccuwage/model.py +++ b/pyaccuwage/model.py @@ -4,15 +4,11 @@ import collections class Model(object): - record_length = -1 record_identifier = ' ' required = False target_size = 512 def __init__(self): - if self.record_length == -1: - raise ValueError(self.record_length) - for (key, value) in list(self.__class__.__dict__.items()): if isinstance(value, Field): # GRAB THE FIELD INSTANCE FROM THE CLASS DEFINITION @@ -23,27 +19,17 @@ class Model(object): if not src_field.name: setattr(src_field, 'name', key) setattr(src_field, 'parent_name', self.__class__.__name__) - new_field_instance = copy.copy(src_field) - new_field_instance._orig_value = None - new_field_instance._value = new_field_instance.value - self.__dict__[key] = new_field_instance + self.__dict__[key] = copy.copy(src_field) def __setattr__(self, key, value): if hasattr(self, key) and isinstance(getattr(self, key), Field): - self.set_field_value(key, value) + getattr(self, key).value = value else: # MAYBE THIS SHOULD RAISE A PROPERTY ERROR? self.__dict__[key] = value - def set_field_value(self, field_name, value): - getattr(self, field_name).value = value - def get_fields(self): - identifier = TextField( - "record_identifier", - max_length = len(self.record_identifier), - blank = len(self.record_identifier) == 0, - creation_counter=-1) + identifier = TextField("record_identifier", max_length=len(self.record_identifier), creation_counter=-1) identifier.value = self.record_identifier fields = [identifier] @@ -69,22 +55,13 @@ class Model(object): if isinstance(custom_validator, collections.Callable): custom_validator(f) - def output(self, format='binary'): - if format == 'text': - return self.output_text() - return self.output_efile() - - def output_efile(self): + def output(self): result = b''.join([field.get_data() for field in self.get_sorted_fields()]) - if self.record_length < 0 or len(result) != self.record_length: - raise ValidationError("Record result length not equal to %d bytes (%d)" % (self.record_length, len(result))) - return result - def output_text(self): - fields = self.get_sorted_fields()[1:] # skip record identifier - fields = [field for field in fields if not field.is_read_only] - header = ''.join(['---', self.__class__.__name__, '\n']) - return header + '\n'.join([f.name + ': ' + (str(f.value) if f.value else '') for f in fields]) + '\n\n' + if hasattr(self, 'record_length') and len(result) != self.record_length: + raise ValidationError("Record result length not equal to %d bytes (%d)" % (self.record_length, len(result))) + + return result def read(self, fp): # Skip the first record, since that's an identifier @@ -100,9 +77,6 @@ class Model(object): def fromJSON(self, o): fields = o['fields'] - identifier, fields = fields[0], fields[1:] - assert(identifier.value == self.record_identifier) - for f in fields: target = self.__dict__[f.name] @@ -110,7 +84,12 @@ class Model(object): or target.max_length != f.max_length): print("Warning: value mismatch on import") - target.value = f.value + target._value = f._value + + + #print (self.__dict__[f.name].name == f.name) + #self.__dict__[f.name].name == f.name + #self.__dict__[f.name].max_length == f.max_length return self diff --git a/pyaccuwage/modeldef.py b/pyaccuwage/modeldef.py index 6d4ce35..c6c9110 100644 --- a/pyaccuwage/modeldef.py +++ b/pyaccuwage/modeldef.py @@ -2,7 +2,7 @@ import re class ClassEntryCommentSequence(object): - re_rangecomment = re.compile(r'#\s+(\d+)\-?(\d*)$') + re_rangecomment = re.compile('#\s+(\d+)\-?(\d*)$') def __init__(self, classname, line): self.classname = classname, @@ -72,7 +72,7 @@ class ModelDefParser(object): classmatch = self.re_classdef.match(line) if classmatch: - classname, _subclass = classmatch.groups() + classname, subclass = classmatch.groups() self.beginclass(classname, self.line) continue diff --git a/pyaccuwage/parser.py b/pyaccuwage/parser.py index c0fe399..6b808fc 100644 --- a/pyaccuwage/parser.py +++ b/pyaccuwage/parser.py @@ -1,3 +1,5 @@ +#!/usr/bin/python +# coding=UTF-8 """ Parser utility to read data from Publication 1220 and convert it into python classes. @@ -109,7 +111,7 @@ class RangeToken(BaseToken): class NumericToken(BaseToken): - regexp = re.compile(r'^(\d+)$') + regexp = re.compile('^(\d+)$') @property def value(self): @@ -144,7 +146,8 @@ class RecordBuilder(object): (re.compile(r'zero\-filled', re.IGNORECASE), +1), (re.compile(r'leading zeroes', re.IGNORECASE), +1), - (re.compile(r'left\-justif', re.IGNORECASE), -1), + (re.compile(r'left-\justif', re.IGNORECASE), -1), + ], }, }), diff --git a/pyaccuwage/pdfextract.py b/pyaccuwage/pdfextract.py index 352c400..2903b5d 100644 --- a/pyaccuwage/pdfextract.py +++ b/pyaccuwage/pdfextract.py @@ -3,102 +3,313 @@ import subprocess import re -import itertools -import fitz +import pdb """ pdftotext -layout -nopgbrk p1220.pdf - """ -def strip_values(items): - expr_non_alphanum = re.compile(r'[^\w\s]*', re.MULTILINE) - return [expr_non_alphanum.sub(x, '').strip().replace('\n', ' ') for x in items if x] class PDFRecordFinder(object): - field_range_expr = re.compile(r'^(\d+)[-]?(\d*)$') + def __init__(self, src, heading_exp=None): + if not heading_exp: + heading_exp = re.compile('(\s+Record Name: (.*))|Record\ Layout') - def __init__(self, src): - self.document = fitz.open(src) + field_heading_exp = re.compile('^Field.*Field.*Length.*Description') - def find_record_table_ranges(self): - matches = [] - for (page_number, page) in enumerate(self.document): - header_rects = page.search_for("Record Name:") - for header_match_rect in header_rects: - header_match_rect.x0 = header_match_rect.x1 # Start after match of "Record Name: " - header_match_rect.x1 = page.bound().x1 # Extend to right side of page - header_text = page.get_textbox(header_match_rect) - record_name = re.sub(r'[^\w\s\n]*', '', header_text).strip() - matches.append((record_name, { - 'page': page_number, - 'y': header_match_rect.y1 - 5, # Back up a hair to include header more reliably - })) - return matches - - def find_records(self): - record_ranges = self.find_record_table_ranges() - for record_index, (record_name, record_details) in enumerate(record_ranges): - current_rows = [] - next_index = record_index+1 - (_, next_record_details) = record_ranges[next_index] if next_index < len(record_ranges) else (None, {'page': self.document.page_count-1}) - for page_number in range(record_details['page'], next_record_details['page']): - page = self.document[page_number] - table_search_rect = page.bound() - if page_number == record_details['page']: - table_search_rect.y0 = record_details['y'] - tables = page.find_tables( - clip = table_search_rect, - min_words_horizontal = 1, - min_words_vertical = 1, - horizontal_strategy = "lines_strict", - intersection_tolerance = 1, - ) - for table in tables: - if table.col_count == 4: - table = table.extract() - # Parse field position (sometimes a cell has multiple - # values because IRS employees apparently smoke crack - for row in table: - first_column_lines = row[0].strip().split('\n') - if len(first_column_lines) > 1: - for sub_row in self.split_row(row): - current_rows.append(strip_values(sub_row)) - else: - current_rows.append(strip_values(row)) - consecutive_rows = self.filter_nonconsecutive_rows(current_rows) - yield(record_name, consecutive_rows) - - def split_row(self, row): - if not row[1]: - return [] - split_rows = list(itertools.zip_longest(*[x.strip().split('\n') for x in row[:3]], fillvalue=None)) - description = strip_values([row[3]])[0] - rows = [] - for row in split_rows: - if len(row) < 3 or not row[2]: - row = self.infer_field_length(row) - rows.append([*row, description]) - return rows - - def infer_field_length(self, row): - matches = PDFRecordFinder.field_range_expr.match(row[0]) - if not matches: - return row - (start, end) = ([int(x) for x in list(matches.groups()) if x] + [None])[:2] - length = str(end-start+1) if end and start else '1' - return (*row[:2], length) - - def filter_nonconsecutive_rows(self, rows): - consecutive_rows = [] - last_position = 0 - for row in rows: - matches = PDFRecordFinder.field_range_expr.match(row[0]) - if not matches: - continue - (start, end) = ([int(x) for x in list(matches.groups()) if x] + [None])[:2] - if start != last_position + 1: - continue - last_position = end if end else start - consecutive_rows.append(row) - return consecutive_rows + opts = ["pdftotext", "-layout", "-nopgbrk", "-eol", "unix", src, '-'] + pdftext = subprocess.check_output(opts) + self.textrows = pdftext.split('\n') + self.heading_exp = heading_exp + self.field_heading_exp = field_heading_exp def records(self): - return self.find_records() + headings = self.locate_heading_rows_by_field() + + #for x in headings: + # print x + + for (start, end, name) in headings: + name = name.decode('ascii', 'ignore') + yield (name, list(self.find_fields(iter(self.textrows[start+1:end]))), (start+1, end)) + + + def locate_heading_rows_by_field(self): + results = [] + record_break = [] + line_is_whitespace_exp = re.compile('^(\s*)$') + record_begin_exp = self.heading_exp #re.compile('Record\ Name') + + for (i, row) in enumerate(self.textrows): + match = self.field_heading_exp.match(row) + if match: + # work backwards until we think the header is fully copied + space_count_exp = re.compile('^(\s*)') + position = i - 1 + spaces = 0 + #last_spaces = 10000 + complete = False + header = None + while not complete: + line_is_whitespace = True if line_is_whitespace_exp.match(self.textrows[position]) else False + is_record_begin = record_begin_exp.search(self.textrows[position]) + if is_record_begin or line_is_whitespace: + header = self.textrows[position-1:i] + complete = True + position -= 1 + + name = ''.join(header).strip().decode('ascii','ignore') + print((name, position)) + results.append((i, name, position)) + else: + # See if this row forces us to break from field reading. + if re.search('Record\ Layout', row): + record_break.append(i) + + merged = [] + for (a, b) in zip(results, results[1:] + [(len(self.textrows), None)]): + end_pos = None + + #print a[0], record_break[0], b[0]-1 + + while record_break and record_break[0] < a[0]: + record_break = record_break[1:] + + if record_break[0] < b[0]-1: + end_pos = record_break[0] + record_break = record_break[1:] + else: + end_pos = b[0]-1 + + merged.append( (a[0], end_pos-1, a[1]) ) + return merged + + """ + def locate_heading_rows(self): + results = [] + for (i, row) in enumerate(self.textrows): + match = self.heading_exp.match(row) + if match: + results.append((i, ''.join(match.groups()))) + + merged = [] + for (a, b) in zip(results, results[1:] + [(len(self.textrows),None)]): + merged.append( (a[0], b[0]-1, a[1]) ) + + return merged + + def locate_layout_block_rows(self): + # Search for rows that contain "Record Layout", as these are not fields + # we are interested in because they contain the crazy blocks of field definitions + # and not the nice 4-column ones that we're looking for. + + results = [] + for (i, row) in enumerate(self.textrows): + match = re.match("Record Layout", row) + + """ + + def find_fields(self, row_iter): + cc = ColumnCollector() + blank_row_counter = 0 + + for r in row_iter: + row = r.decode('UTF-8') + #print row + row_columns = self.extract_columns_from_row(row) + + if not row_columns: + if cc.data and len(list(cc.data.keys())) > 1 and len(row.strip()) > list(cc.data.keys())[-1]: + yield cc + cc = ColumnCollector() + else: + cc.empty_row() + continue + + try: + cc.add(row_columns) + + except IsNextField as e: + yield cc + cc = ColumnCollector() + cc.add(row_columns) + except UnknownColumn as e: + raise StopIteration + + yield cc + + + def extract_columns_from_row(self, row): + re_multiwhite = re.compile(r'\s{2,}') + + # IF LINE DOESN'T CONTAIN MULTIPLE WHITESPACES, IT'S LIKELY NOT A TABLE + if not re_multiwhite.search(row): + return None + + white_ranges = [0,] + pos = 0 + while pos < len(row): + match = re_multiwhite.search(row[pos:]) + if match: + white_ranges.append(pos + match.start()) + white_ranges.append(pos + match.end()) + pos += match.end() + else: + white_ranges.append(len(row)) + pos = len(row) + + row_result = [] + white_iter = iter(white_ranges) + while white_iter: + try: + start = next(white_iter) + end = next(white_iter) + if start != end: + row_result.append( + (start, row[start:end].encode('ascii','ignore')) + ) + + except StopIteration: + white_iter = None + + #print row_result + return row_result + + +class UnknownColumn(Exception): + pass + +class IsNextField(Exception): + pass + +class ColumnCollector(object): + def __init__(self, initial=None): + self.data = None + self.column_widths = None + self.max_data_length = 0 + self.adjust_pad = 3 + self.empty_rows = 0 + pass + + def __repr__(self): + return "<%s: %s>" % ( + self.__class__.__name__, + [x if len(x) < 25 else x[:25] + '..' for x in list(self.data.values()) if self.data else '']) + + def add(self, data): + #if self.empty_rows > 2: + # raise IsNextField() + + if not self.data: + self.data = dict(data) + else: + data = self.adjust_columns(data) + if self.is_next_field(data): + raise IsNextField() + for col_id, value in data: + self.merge_column(col_id, value) + + self.update_column_widths(data) + + def empty_row(self): + self.empty_rows += 1 + + def update_column_widths(self, data): + self.last_data_length = len(data) + self.max_data_length = max(self.max_data_length, len(data)) + + if not self.column_widths: + self.column_widths = dict([[column_value[0], column_value[0] + len(column_value[1])] for column_value in data]) + else: + for col_id, value in data: + try: + self.column_widths[col_id] = max(self.column_widths[col_id], col_id + len(value.strip())) + except KeyError: + pass + + def add_old(self, data): + if not self.data: + self.data = dict(data) + else: + if self.is_next_field(data): + raise IsNextField() + for col_id, value in data: + self.merge_column(col_id, value) + + + def adjust_columns(self, data): + adjusted_data = {} + for col_id, value in data: + if col_id in list(self.data.keys()): + adjusted_data[col_id] = value.strip() + else: + for col_start, col_end in list(self.column_widths.items()): + if (col_start - self.adjust_pad) <= col_id and (col_end + self.adjust_pad) >= col_id: + if col_start in adjusted_data: + adjusted_data[col_start] += ' ' + value.strip() + else: + adjusted_data[col_start] = value.strip() + + return list(adjusted_data.items()) + + + def merge_column(self, col_id, value): + if col_id in list(self.data.keys()): + self.data[col_id] += ' ' + value.strip() + else: + # try adding a wiggle room value? + # FIXME: + # Sometimes description columns contain column-like + # layouts, and this causes the ColumnCollector to become + # confused. Perhaps we could check to see if a column occurs + # after the maximum column, and assume it's part of the + # max column? + + """ + for col_start, col_end in self.column_widths.items(): + if col_start <= col_id and (col_end) >= col_id: + self.data[col_start] += ' ' + value.strip() + return + """ + raise UnknownColumn + + def is_next_field(self, data): + """ + If the first key value contains a string + and we already have some data in the record, + then this row is probably the beginning of + the next field. Raise an exception and continue + on with a fresh ColumnCollector. + """ + + """ If the length of the value in column_id is less than the position of the next column_id, + then this is probably a continuation. + """ + + if self.data and data: + keys = list(dict(self.column_widths).keys()) + keys.sort() + keys += [None] + + if self.last_data_length < len(data): + return True + + first_key, first_value = list(dict(data).items())[0] + if list(self.data.keys())[0] == first_key: + + position = keys.index(first_key) + max_length = keys[position + 1] + if max_length: + return len(first_value) > max_length or len(data) == self.max_data_length + + return False + + + @property + def tuple(self): + #try: + if self.data: + return tuple([self.data[k] for k in sorted(self.data.keys())]) + return () + #except: + # import pdb + # pdb.set_trace() + diff --git a/pyaccuwage/record.py b/pyaccuwage/record.py index 6b91123..472dde9 100644 --- a/pyaccuwage/record.py +++ b/pyaccuwage/record.py @@ -105,8 +105,8 @@ class EmployerRecord(EFW2Record): zipcode_ext = TextField(max_length=4, required=False) kind_of_employer = TextField(max_length=1) blank1 = BlankField(max_length=4) - foreign_state_province = TextField(max_length=23, required=False) - foreign_postal_code = TextField(max_length=15, required=False) + foreign_state_province = TextField(max_length=23) + foreign_postal_code = TextField(max_length=15) country_code = TextField(max_length=2, required=False) employment_code = TextField(max_length=1) tax_jurisdiction_code = TextField(max_length=1, required=False) @@ -150,7 +150,7 @@ class EmployeeWageRecord(EFW2Record): ssn = IntegerField(max_length=9, required=False) employee_first_name = TextField(max_length=15) - employee_middle_name = TextField(max_length=15, required=False) + employee_middle_name = TextField(max_length=15) employee_last_name = TextField(max_length=20) employee_suffix = TextField(max_length=4, required=False) location_address = TextField(max_length=22) @@ -163,7 +163,7 @@ class EmployeeWageRecord(EFW2Record): blank1 = BlankField(max_length=5) foreign_state = TextField(max_length=23, required=False) foreign_postal_code = TextField(max_length=15, required=False) - country = TextField(max_length=2, required=True, blank=True) + country = TextField(max_length=2) wages_tips = MoneyField(max_length=11) federal_income_tax_withheld = MoneyField(max_length=11) social_security_wages = MoneyField(max_length=11) @@ -199,10 +199,8 @@ class EmployeeWageRecord(EFW2Record): blank6 = BlankField(max_length=23) def validate_ssn(self, f): - if str(f.value).startswith('666'): - raise ValidationError("ssn cannot start with 666", field=f) - if str(f.value).startswith('9'): - raise ValidationError("ssn cannot start with 9", field=f) + if str(f.value).startswith('666','9'): + raise ValidationError("ssn cannot start with 666 or 9", field=f) @@ -245,7 +243,7 @@ class StateWageRecord(EFW2Record): taxing_entity_code = TextField(max_length=5, required=False) ssn = IntegerField(max_length=9, required=False) employee_first_name = TextField(max_length=15) - employee_middle_name = TextField(max_length=15, required=False) + employee_middle_name = TextField(max_length=15) employee_last_name = TextField(max_length=20) employee_suffix = TextField(max_length=4, required=False) location_address = TextField(max_length=22) @@ -259,20 +257,20 @@ class StateWageRecord(EFW2Record): foreign_postal_code = TextField(max_length=15, required=False) country_code = TextField(max_length=2, required=False) optional_code = TextField(max_length=2, required=False) - reporting_period = MonthYearField(required=False) + reporting_period = MonthYearField() quarterly_unemp_ins_wages = MoneyField(max_length=11) quarterly_unemp_ins_taxable_wages = MoneyField(max_length=11) - number_of_weeks_worked = IntegerField(max_length=2, required=False) + number_of_weeks_worked = IntegerField(max_length=2) date_first_employed = DateField(required=False) date_of_separation = DateField(required=False) blank2 = BlankField(max_length=5) - state_employer_account_num = IntegerField(max_length=20, required=False) + state_employer_account_num = TextField(max_length=20) blank3 = BlankField(max_length=6) state_code_2 = StateField(use_numeric=True) state_taxable_wages = MoneyField(max_length=11) state_income_tax_wh = MoneyField(max_length=11) other_state_data = TextField(max_length=10, required=False) - tax_type_code = TextField(max_length=1, required=False) # VALIDATE C, D, E, or F + tax_type_code = TextField(max_length=1) # VALIDATE C, D, E, or F local_taxable_wages = MoneyField(max_length=11) local_income_tax_wh = MoneyField(max_length=11) state_control_number = IntegerField(max_length=7, required=False) @@ -282,8 +280,7 @@ class StateWageRecord(EFW2Record): def validate_tax_type_code(self, field): choices = [x for x,y in enums.tax_type_codes] - value = field.value - if value and value.upper() not in choices: + if field.value.upper() not in choices: raise ValidationError("%s not one of %s" % (field.value,choices), field=f) @@ -367,7 +364,7 @@ class StateTotalRecordIA(EFW2Record): state_income_tax_wh = MoneyField(max_length=15) employer_ben = TextField(max_length=8) iowa_confirmation_number = ZeroField(max_length=10) - blank1 = BlankField(max_length=455) + blank1 = BlankField(455) class FinalRecord(EFW2Record): diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 82813ad..0000000 --- a/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -PyMuPDF==1.24.0 diff --git a/scripts/pyaccuwage-convert b/scripts/pyaccuwage-convert deleted file mode 100755 index 9239cac..0000000 --- a/scripts/pyaccuwage-convert +++ /dev/null @@ -1,76 +0,0 @@ -#!/usr/bin/env python -import pyaccuwage -import argparse -import os, os.path -import sys - -""" -Command line tool for converting IRS e-file fixed field records -to/from JSON or a simple text format. - -Attempts to load record types from a python module in the current working -directory named record_types.py - -The module must export a RECORD_TYPES list with the names of the classes to -import as valid record types. -""" - -def get_record_types(): - try: - sys.path.append(os.getcwd()) - import record_types - r = {} - for record_type in record_types.RECORD_TYPES: - r[record_type] = getattr(record_types, record_type) - return r - except ImportError: - print('warning: using default record types (failed to import record_types.py)') - return pyaccuwage.get_record_types() - - -def read_file(fd, filename, record_types): - filename, extension = os.path.splitext(filename) - if extension == '.json': - return pyaccuwage.json_load(fd, record_types) - elif extension == '.txt': - return pyaccuwage.text_load(fd, record_types) - else: - return pyaccuwage.load(fd, record_types) - - -def write_file(outfile, filename, records): - filename, extension = os.path.splitext(filename) - if extension == '.json': - pyaccuwage.json_dump(outfile, records) - elif extension == '.txt': - pyaccuwage.text_dump(outfile, records) - else: - pyaccuwage.dump(outfile, records) - - -if __name__ == '__main__': - parser = argparse.ArgumentParser( - description="Convert accuwage efile data between different formats." - ) - - parser.add_argument("-i", '--input', - nargs=1, - required=True, - metavar="file", - type=argparse.FileType('r'), - help="Source file to convert") - - parser.add_argument("-o", "--output", - nargs=1, - required=True, - metavar="file", - type=argparse.FileType('w'), - help="Destination file to output") - - args = parser.parse_args() - in_file = args.input[0] - out_file = args.output[0] - - records = list(read_file(in_file, in_file.name, get_record_types())) - write_file(out_file, out_file.name, records) - print("wrote {} records to {}".format(len(records), out_file.name)) diff --git a/scripts/pyaccuwage-pdfparse b/scripts/pyaccuwage-pdfparse index d80abaa..6a35387 100755 --- a/scripts/pyaccuwage-pdfparse +++ b/scripts/pyaccuwage-pdfparse @@ -1,4 +1,4 @@ -#!/usr/bin/env python +#!/usr/bin/python from pyaccuwage.parser import RecordBuilder from pyaccuwage.pdfextract import PDFRecordFinder import argparse @@ -29,9 +29,48 @@ doc = PDFRecordFinder(source_file) records = doc.records() builder = RecordBuilder() -for (name, fields) in records: - name = re.sub(r'^[^a-zA-Z]*','', name.split(':')[-1]) - name = re.sub(r'[^\w]*', '', name) - sys.stdout.write("\nclass %s(pyaccuwagemodel.Model):\n" % name) - for field in builder.load(map(lambda x: x, fields[0:])): +def record_begins_at(field): + return int(fields[0].data.values()[0].split('-')[0], 10) + +def record_ends_at(fields): + return int(fields[-1].data.values()[0].split('-')[-1], 10) + +last_record_begins_at = -1 +last_record_ends_at = -1 + +for rec in records: + #if not rec[1]: + # continue # no actual fields detected + fields = rec[1] + + # strip out fields that are not 4 items long + fields = filter(lambda x:len(x.tuple) == 4, fields) + + # strip fields that don't begin at position 0 + fields = filter(lambda x: 0 in x.data, fields) + + # strip fields that don't have a length-range type item in position 0 + fields = filter(lambda x: re.match('^\d+[-]?\d*$', x.data[0]), fields) + + if not fields: + continue + + begins_at = record_begins_at(fields) + ends_at = record_ends_at(fields) + + # FIXME record_ends_at is randomly exploding due to record data being + # a lump of text and not necessarily a field entry. I assume + # this is cleaned out by the record builder class. + + #print last_record_ends_at + 1, begins_at + if last_record_ends_at + 1 != begins_at: + name = re.sub('^[^a-zA-Z]*','',rec[0].split(':')[-1]) + name = re.sub('[^\w]*', '', name) + sys.stdout.write("\nclass %s(pyaccuwagemodel.Model):\n" % name) + + for field in builder.load(map(lambda x:x.tuple, rec[1][0:])): sys.stdout.write('\t' + field + '\n') + #print field + + last_record_ends_at = ends_at + diff --git a/setup.py b/setup.py index cdef46b..b543ddb 100644 --- a/setup.py +++ b/setup.py @@ -7,14 +7,13 @@ def pyaccuwage_tests(): return test_suite setup(name='pyaccuwage', - version='0.2025.0', + version='0.2018.1', packages=['pyaccuwage'], scripts=[ - 'scripts/pyaccuwage-checkseq', - 'scripts/pyaccuwage-convert', - 'scripts/pyaccuwage-genfieldfill', 'scripts/pyaccuwage-parse', 'scripts/pyaccuwage-pdfparse', + 'scripts/pyaccuwage-checkseq', + 'scripts/pyaccuwage-genfieldfill' ], zip_safe=True, test_suite='setup.pyaccuwage_tests', diff --git a/tests/test_fields.py b/tests/test_fields.py index 2707e6f..9293acd 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -1,16 +1,17 @@ import unittest +import decimal from pyaccuwage.fields import TextField -from pyaccuwage.fields import StaticField -# from pyaccuwage.fields import IntegerField -# from pyaccuwage.fields import StateField -# from pyaccuwage.fields import BlankField -# from pyaccuwage.fields import ZeroField -# from pyaccuwage.fields import MoneyField +from pyaccuwage.fields import IntegerField +from pyaccuwage.fields import StateField +from pyaccuwage.fields import BlankField +from pyaccuwage.fields import ZeroField +from pyaccuwage.fields import MoneyField from pyaccuwage.fields import ValidationError from pyaccuwage.model import Model class TestTextField(unittest.TestCase): + def testStringShortOptional(self): field = TextField(max_length=6, required=False) field.validate() # optional @@ -29,39 +30,43 @@ class TestTextField(unittest.TestCase): def testStringLongOptional(self): field = TextField(max_length=6, required=False) field.value = 'Hello, World!' # too long - data = field.get_data() - self.assertEqual(len(data), field.max_length) - self.assertEqual(data, b'HELLO,') + self.assertEqual(len(field.get_data()), field.max_length) - def testStringUnsetOptional(self): - field = TextField(max_length=6, required=False) - field.validate() - self.assertEqual(field.get_data(), b' ' * 6) - def testStringRequiredUnassigned(self): - field = TextField(max_length=6) - self.assertRaises(ValidationError, lambda: field.validate()) +class TestModelOutput(unittest.TestCase): + class TestModel(Model): + record_length = 128 + record_identifier = 'TEST' # 4 bytes + field1 = TextField(max_length=16) + field2 = IntegerField(max_length=16) + blank1 = BlankField(max_length=16) + zero1 = ZeroField(max_length=16) + money = MoneyField(max_length=32) + state_txt = StateField() + state_num = StateField(use_numeric=True) + blank2 = BlankField(max_length=24) - def testStringRequiredNonBlank(self): - field = TextField(max_length=6) - field.value = '' - self.assertRaises(ValidationError, lambda: field.validate()) + def setUp(self): + self.model = TestModelOutput.TestModel() - def testStringRequiredBlank(self): - field = TextField(max_length=6, blank=True) - field.value = '' - field.validate() - self.assertEqual(len(field.get_data()), 6) + def testModelOutput(self): + model = self.model + model.field1.value = 'Hello, sir!' + model.field2.value = 12345 + model.money.value = decimal.Decimal('1234.56') + model.state_txt.value = 'IA' + model.state_num.value = 'IA' - def testStringMinimumLength(self): - field = TextField(max_length=6, min_length=6, blank=True) # blank has no effect - field.value = '' # one character too short - self.assertRaises(ValidationError, lambda: field.validate()) - field.value = '12345' # one character too short - self.assertRaises(ValidationError, lambda: field.validate()) - field.value = '123456' # one character too short + expected = b''.join([ + b'TEST', + b'HELLO, SIR!'.ljust(16), + b'12345'.zfill(16), + b' ' * 16, + b'0' * 16, + b'123456'.zfill(32), + b'IA', + b'19', + b' ' * 24, + ]) -class TestStaticField(unittest.TestCase): - def test_static_field(self): - field = StaticField(value='TEST') - self.assertEqual(field.get_data(), b'TEST') + self.assertEqual(model.output(), expected) diff --git a/tests/test_records.py b/tests/test_records.py deleted file mode 100644 index 67ce3ce..0000000 --- a/tests/test_records.py +++ /dev/null @@ -1,179 +0,0 @@ -import unittest -import decimal -import pyaccuwage -from pyaccuwage.fields import BlankField -from pyaccuwage.fields import IntegerField -from pyaccuwage.fields import MoneyField -from pyaccuwage.fields import StateField -from pyaccuwage.fields import TextField -from pyaccuwage.fields import ZeroField -from pyaccuwage.fields import StaticField -from pyaccuwage.fields import ValidationError -from pyaccuwage.model import Model - -class TestModelOutput(unittest.TestCase): - class TestModel(Model): - record_length = 128 - record_identifier = 'TEST' # 4 bytes - field1 = TextField(max_length=16) - field2 = IntegerField(max_length=16) - blank1 = BlankField(max_length=16) - zero1 = ZeroField(max_length=16) - money = MoneyField(max_length=32) - state_txt = StateField() - state_num = StateField(use_numeric=True) - blank2 = BlankField(max_length=12) - static1 = StaticField(value='hey mister!!') - - def setUp(self): - self.model = TestModelOutput.TestModel() - - def testModelBinaryOutput(self): - model = self.model - model.field1.value = 'Hello, sir!' - model.field2.value = 12345 - model.money.value = decimal.Decimal('3133.77') - model.state_txt.value = 'IA' - model.state_num.value = 'IA' - - expected = b''.join([ - b'TEST', - b'HELLO, SIR!'.ljust(16), - b'12345'.zfill(16), - b' ' * 16, - b'0' * 16, - b'313377'.zfill(32), - b'IA', - b'19', - b' ' * 12, - b'hey mister!!', - ]) - - output = model.output() - self.assertEqual(len(output), TestModelOutput.TestModel.record_length) - self.assertEqual(output, expected) - - def testModelTextOutput(self): - model = self.model - model.field1.value = 'Hello, sir!' - model.field2.value = 12345 - model.money.value = decimal.Decimal('3133.77') - model.state_txt.value = 'IA' - model.state_num.value = 'IA' - output = model.output(format='text') - - self.assertEqual(output, '''---TestModel -field1: Hello, sir! -field2: 12345 -money: 3133.77 -state_txt: IA -state_num: IA -static1: hey mister!! - -''') - - -class TestFileFormats(unittest.TestCase): - class TestModelA(pyaccuwage.model.Model): - record_length = 128 - record_identifier = 'A' # 1 byte - field1 = TextField(max_length=16) - field2 = IntegerField(max_length=16) - blank1 = BlankField(max_length=16) - zero1 = ZeroField(max_length=16) - money = MoneyField(max_length=32) - state_txt = StateField() - state_num = StateField(use_numeric=True) - blank2 = BlankField(max_length=27) - - class TestModelB(pyaccuwage.model.Model): - record_length = 128 - record_identifier = 'B' # 1 byte - zero1 = ZeroField(max_length=32) - text1 = TextField(max_length=71) - text2 = TextField(max_length=20, required=False) - blank2 = BlankField(max_length=4) - - record_types = [TestModelA, TestModelB] - - def createExampleRecords(self): - model_a = TestFileFormats.TestModelA() - model_a.field1.value = 'I am model a' - model_a.field2.value = 5522 - model_a.money.value = decimal.Decimal('23.00') - model_a.state_txt.value = 'IA' - model_a.state_num.value = 'IA' - - model_b = TestFileFormats.TestModelB() - model_b.text1.value = 'hey I am model b and I have a big text field' - - return [ - model_a, - model_b, - ] - - def testJSONSerialization(self): - records = self.createExampleRecords() - record_types = self.record_types - json_data = pyaccuwage.json_dumps(records) - records_loaded = pyaccuwage.json_loads(json_data, record_types) - - original_bytes = pyaccuwage.dumps(records) - reloaded_bytes = pyaccuwage.dumps(records_loaded) - self.assertEqual(original_bytes, reloaded_bytes) - - def testTxtSerialization(self): - records = self.createExampleRecords() - record_types = self.record_types - text_data = pyaccuwage.text_dumps(records) - records_loaded = pyaccuwage.text_loads(text_data, record_types) - - original_bytes = pyaccuwage.dumps(records) - reloaded_bytes = pyaccuwage.dumps(records_loaded) - self.assertEqual(original_bytes, reloaded_bytes) - - -class TestRequiredFields(unittest.TestCase): - def createTestRecord(self, required=False, blank=False): - class Record(pyaccuwage.model.Model): - record_length = 16 - record_identifier = '' - test_field = TextField(max_length=16, required=required, blank=blank) - record = Record() - def dump(): - return pyaccuwage.dumps([record]) - return (record, dump) - - def testRequiredBlankField(self): - (record, dump) = self.createTestRecord(required=True, blank=True) - record.test_field.value # if nothing is ever assigned, raise error - self.assertRaises(ValidationError, dump) - record.test_field.value = '' # value may be empty string - dump() - - def testRequiredNonblankField(self): - (record, dump) = self.createTestRecord(required=True, blank=False) - record.test_field.value # if nothing is ever assigned, raise error - self.assertRaises(ValidationError, dump) - record.test_field.value = '' # value must not be empty string - self.assertRaises(ValidationError, dump) - record.test_field.value = 'hello' - dump() - - def testOptionalBlankField(self): - (record, dump) = self.createTestRecord(required=False, blank=True) - record.test_field.value # OK if nothing is ever assigned - dump() - record.test_field.value = '' # OK if empty string is assigned - dump() - record.test_field.value = 'hello' - dump() - - def testOptionalNonBlankField(self): - (record, dump) = self.createTestRecord(required=False, blank=False) - record.test_field.value # OK if nothing is ever assigned - dump() - record.test_field.value = '' # OK if empty string is assigned - dump() - record.test_field.value = 'hello' - dump()