datamule 2.0.5__py3-none-any.whl → 2.0.6__py3-none-any.whl

datamule/document/document.py

@@ -8,11 +8,12 @@ from ..mapping_dicts.txt_mapping_dicts import dict_10k, dict_10q, dict_8k, dict_
 from ..mapping_dicts.xml_mapping_dicts import dict_345
 from ..mapping_dicts.html_mapping_dicts import *
 from selectolax.parser import HTMLParser
-from .processing import process_tabular_data
+
 from pathlib import Path
 import webbrowser
 from secsgml.utils import bytes_to_str
 
+from .tables.tables import Tables
 
 class Document:
     def __init__(self, type, content, extension,accession,filing_date,path=None):
@@ -33,7 +34,9 @@ class Document:
 
         self.extension = extension
         # this will be filled by parsed
-        self.data = None
+        self._data = None
+        self._tables = None
+
 
 
     #_load_text_content
@@ -107,7 +110,7 @@ class Document:
     # Note: this method will be heavily modified in the future
     def parse(self):
         # check if we have already parsed the content
-        if self.data:
+        if self._data:
             return
         
         mapping_dict = None
@@ -125,8 +128,8 @@ class Document:
             elif self.type == 'SC 13G':
                 mapping_dict = dict_13g
             
-            self.data = {}
-            self.data['document'] = dict2dict(txt2dict(content=content, mapping_dict=mapping_dict))
+            self._data = {}
+            self._data['document'] = dict2dict(txt2dict(content=content, mapping_dict=mapping_dict))
         elif self.extension in ['.htm', '.html']:
             
             if self.type == '1-K':
@@ -204,16 +207,22 @@ class Document:
                 mapping_dict = dict_nt10k_html
             
             dct = html2dict(content=self.content, mapping_dict=mapping_dict)
-            self.data = dct
+            self._data = dct
         elif self.extension == '.xml':
             if self.type in ['3', '4', '5', '3/A', '4/A', '5/A']:
                 mapping_dict = dict_345
             
-            self.data = xml2dict(content=self.content, mapping_dict=mapping_dict)
+            self._data = xml2dict(content=self.content, mapping_dict=mapping_dict)
         elif self.extension == '.pdf':
-            self.data = pdf2dict(content=self.content, mapping_dict=mapping_dict)
+            self._data = pdf2dict(content=self.content, mapping_dict=mapping_dict)
         else:
             pass
+
+    @property
+    def data(self):
+        if self._data is None:
+            self.parse()
+        return self._data
     
     def write_json(self, output_filename=None):
         if not self.data:
@@ -222,21 +231,27 @@ class Document:
         with open(output_filename, 'w',encoding='utf-8') as f:
             json.dump(self.data, f, indent=2)
 
-    def tables(self):
-        if self.type == 'submission_metadata':
-            return process_tabular_data(self)
-        elif self.extension != '.xml':
-            return []
+    def parse_tables(self):
+        if self.extension != '.xml':
+            self._tables = []
         else:
-            self.parse()
-            return process_tabular_data(self)
+            # Use the property to trigger parsing if needed
+            data = self.data
+            tables = Tables(document_type = self.type, accession=self.accession, data=data)
+            self._tables = tables.tables
+
+    @property
+    def tables(self):
+        if self._tables is None:
+            self.parse_tables()
+        return self._tables
 
 
     def write_csv(self, output_folder):
         output_folder = Path(output_folder)
         output_folder.mkdir(exist_ok=True)
             
-        tables = self.tables()
+        tables = self.tables
 
         if not tables:
             return
@@ -315,13 +330,13 @@ class Document:
    
    # TODO CHANGE THIS
     def __iter__(self):
-        self.parse()
+        # Use the property to trigger parsing if needed
+        document_data = self.data
 
         # Let's remove XML iterable for now
 
         # Handle text-based documents
         if self.extension in ['.txt', '.htm', '.html']:
-            document_data = self.data
             if not document_data:
                 return iter([])
                 

datamule/document/tables/tables.py

@@ -0,0 +1,129 @@
+from .tables_ownership import config_ownership
+from .tables_13fhr import mapping_13fhr 
+from .tables_informationtable import config_information_table
+from .tables_25nse import config_25nse
+from .tables_npx import config_npx
+from .tables_sbsef import config_sbsef
+from .tables_sdr import config_sdr
+from .tables_proxyvotingrecord import config_proxyvotingrecord
+ 
+from .utils import safe_get, flatten_dict
+# will add filing date param later? or extension
+all_tables_dict = {
+    '3' : config_ownership,
+    '3/A' : config_ownership,
+    '4' : config_ownership,
+    '4/A' : config_ownership,
+    '5' : config_ownership,
+    '5/A' : config_ownership,
+    '13F-HR' : mapping_13fhr,
+    '13F-HR/A' : mapping_13fhr,
+    '13F-NT' : mapping_13fhr,
+    '13F-NT/A' : mapping_13fhr,
+    'INFORMATION TABLE' : config_information_table,
+    '25-NSE' : config_25nse,
+    '25-NSE/A' : config_25nse,
+    'N-PX' : config_npx,
+    'N-PX/A' : config_npx,
+    'SBSEF' : config_sbsef,
+    'SBSEF/A' : config_sbsef,
+    'SBSEF-V' : config_sbsef,
+    'SBSEF-W' : config_sbsef,
+    'SDR' : config_sdr,
+    'SDR/A' : config_sdr,
+    'SDR-W' : config_sdr,
+    'SDR-A' : config_sdr,
+    'PROXY VOTING RECORD' : config_proxyvotingrecord,
+}
+
+# process_ex102_abs will need to be done later
+# process d
+# 144
+
+def seperate_data(tables_dict, data):
+    data_list = []
+    
+    for table_name, config in tables_dict.items():
+        path = config['path']
+        
+        # Extract data at the specific path
+        table_data = safe_get(data, path.split('.'))
+        if not table_data:
+            continue
+            
+        # Find sub-paths to exclude (only for paths that have sub-tables)
+        sub_paths = [other_path for other_path in [c['path'] for c in tables_dict.values()] 
+                    if other_path.startswith(path + '.')]
+        
+        # Only apply exclusions if this path has sub-paths AND the data is a dict
+        if sub_paths and isinstance(table_data, dict):
+            exclude_keys = {sp.split('.')[len(path.split('.'))] for sp in sub_paths}
+            table_data = {k: v for k, v in table_data.items() if k not in exclude_keys}
+        
+        data_list.append((table_name, table_data))
+    
+    return data_list
+
+def apply_mapping(flattened_data, mapping_dict, accession):
+    """Apply mapping to flattened data and add accession"""
+    
+    # Handle case where flattened_data is a list of dictionaries
+    if isinstance(flattened_data, list):
+        results = []
+        for data_dict in flattened_data:
+            results.append(apply_mapping(data_dict, mapping_dict, accession))
+        return results
+    
+    # Original logic for single dictionary
+    ordered_row = {'accession': accession}
+    
+    # Apply mapping for all other keys
+    for old_key, new_key in mapping_dict.items():
+        if old_key in flattened_data:
+            ordered_row[new_key] = flattened_data.pop(old_key)
+        else:
+            ordered_row[new_key] = None
+    
+    # Add any remaining keys that weren't in the mapping
+    for key, value in flattened_data.items():
+        ordered_row[key] = value
+    
+    return ordered_row
+
+# should have table type, accession, data
+class Table:
+    def __init__(self,data,name,accession):
+        self.data = data
+        self.name = name
+        self.accession = accession
+
+
+class Tables():
+    def __init__(self,document_type,accession,data):
+        self.document_type = document_type
+        self.accession = accession
+        self.data = data
+
+        # to fill in
+        self.tables = []
+
+        self.parse_tables()
+
+    def parse_tables(self):
+        # first select dict
+
+        try:
+            tables_dict = all_tables_dict[self.document_type]
+        except:
+            raise ValueError(f"Table not found: {self.document_type}.")
+        
+        # now get the dicts from the data
+        data_dicts = seperate_data(tables_dict,self.data)
+        
+        # now flatten
+        data_dicts = [(x,flatten_dict(y)) for x,y in data_dicts]
+        
+        for table_name, flattened_data in data_dicts:
+            mapping_dict = tables_dict[table_name]['mapping']
+            mapped_data = apply_mapping(flattened_data, mapping_dict, self.accession)
+            self.tables.append(Table(mapped_data, table_name, self.accession))

datamule/document/{mappings/thirteenfhr.py → tables/tables_13fhr.py}

@@ -1,7 +1,4 @@
-# Ready for mass testing
-
-# 13F-HR (Institutional Investment Manager Holdings) mapping
-thirteenfhr_dict =  {
+mapping_13fhr =  {
     # Cover Page Mapping
     'formData_coverPage_reportCalendarOrQuarter': 'reportCalendarOrQuarter',
     'formData_coverPage_filingManager_name': 'filingManagerName',
@@ -69,4 +66,11 @@ thirteenfhr_dict =  {
     'schemaLocation': 'schemaLocation',
     'schemaVersion': 'schemaVersion',
     'accession': 'accessionNumber'
+}
+
+config_13fhr = {
+   '13fhr': {
+       'path': 'edgarSubmission',
+       'mapping': mapping_13fhr
+   }
 }

datamule/document/{mappings/twentyfivense.py → tables/tables_25nse.py}

@@ -1,5 +1,3 @@
-# Ready for mass testing
-# 25-NSE mapping
 twentyfive_nse_dict = {
     'descriptionClassSecurity': 'securityDescription',
     'exchange_cik': 'exchangeCik',
@@ -19,4 +17,11 @@ twentyfive_nse_dict = {
     'signatureData_signatureDate': 'signatureDate',
     'signatureData_signatureName': 'signatureName',
     'signatureData_signatureTitle': 'signatureTitle'
+}
+
+config_25nse = {
+   '25nse': {
+       'path': 'notificationOfRemoval',
+       'mapping': twentyfive_nse_dict
+   }
 }

datamule/document/{mappings/information_table.py → tables/tables_informationtable.py}

@@ -1,6 +1,3 @@
-# Ready for mass testing
-
-# Information Table (13F-HR Securities) mapping
 information_table_dict = {
     'nameOfIssuer': 'nameOfIssuer',
     'titleOfClass': 'titleOfClass',
@@ -33,3 +30,10 @@ information_table_dict = {
     'infoTable_votingAuthority_Sole': 'infoTableVotingAuthoritySole',
     'schemaLocation': 'schemaLocation'
 }
+
+config_information_table = {
+   'informationtable': {
+       'path': 'informationTable.infoTable',
+       'mapping': information_table_dict
+   }
+}

datamule/document/{mappings/npx.py → tables/tables_npx.py}

@@ -82,4 +82,11 @@ npx_dict = {
     'headerData_seriesClass_reportSeriesClass_rptSeriesClassInfo_includeAllClassesFlag': 'includeAllClassesFlag',
     'headerData_seriesClass_reportSeriesClass_rptSeriesClassInfo_seriesId': 'headerSeriesId',
     'headerData_submissionType': 'submissionType'
+}
+
+config_npx = {
+   'npx': {
+       'path': 'edgarSubmission',
+       'mapping': npx_dict
+   }
 }

datamule/document/{mappings/ownership.py → tables/tables_ownership.py}

@@ -1,7 +1,5 @@
-# Ready for mass testing
-
 # Non-derivative transaction ownership mapping
-non_derivative_transaction_ownership_dict = {
+non_derivative_transaction_mapping = {
     'securityTitle_value': 'securityTitle',
     'securityTitle_footnote': 'securityTitleFootnote',
     'transactionDate_value': 'transactionDate',
@@ -31,7 +29,7 @@ non_derivative_transaction_ownership_dict = {
 }
 
 # Derivative transaction ownership mapping
-derivative_transaction_ownership_dict = {
+derivative_transaction_mapping = {
     'securityTitle_value': 'securityTitle',
     'securityTitle_footnote': 'securityTitleFootnote',
     'conversionOrExercisePrice_value': 'conversionOrExercisePrice',
@@ -75,7 +73,7 @@ derivative_transaction_ownership_dict = {
 }
 
 # Non-derivative holding ownership mapping
-non_derivative_holding_ownership_dict = {
+non_derivative_holding_mapping = {
     'securityTitle_value': 'securityTitle',
     'securityTitle_footnote': 'securityTitleFootnote',
     'postTransactionAmounts_sharesOwnedFollowingTransaction_value': 'sharesOwnedFollowingTransaction',
@@ -91,7 +89,7 @@ non_derivative_holding_ownership_dict = {
 }
 
 # Derivative holding ownership mapping
-derivative_holding_ownership_dict = {
+derivative_holding_mapping = {
     'securityTitle_value': 'securityTitle',
     'securityTitle_footnote': 'securityTitleFootnote',
     'conversionOrExercisePrice_value': 'conversionOrExercisePrice',
@@ -119,7 +117,7 @@ derivative_holding_ownership_dict = {
 }
 
 # Reporting owner ownership mapping
-reporting_owner_ownership_dict = {
+reporting_owner_mapping = {
     'reportingOwnerAddress_rptOwnerCity': 'rptOwnerCity',
     'reportingOwnerAddress_rptOwnerState': 'rptOwnerState',
     'reportingOwnerAddress_rptOwnerStateDescription': 'rptOwnerStateDescription',
@@ -137,7 +135,7 @@ reporting_owner_ownership_dict = {
 }
 
 # Metadata ownership mapping
-metadata_ownership_dict = {
+metadata_mapping = {
     'periodOfReport': 'periodOfReport',
     'issuer_issuerCik': 'issuerCik',
     'issuer_issuerName': 'issuerName',
@@ -156,8 +154,38 @@ metadata_ownership_dict = {
 }
 
 # Owner signature ownership mapping
-owner_signature_ownership_dict = {
+owner_signature_mapping = {
     'signatureName': 'signatureName',
     'signatureDate': 'signatureDate'
 }
 
+config_ownership = {
+    'non_derivative_holding_ownership': {
+        'path': 'ownershipDocument.nonDerivativeTable.nonDerivativeHolding',
+        'mapping': non_derivative_holding_mapping
+    },
+    'non_derivative_transaction_ownership': {
+        'path': 'ownershipDocument.nonDerivativeTable.nonDerivativeTransaction',
+        'mapping': non_derivative_transaction_mapping
+    }, 
+    'derivative_holding_ownership': {
+        'path': 'ownershipDocument.derivativeTable.derivativeHolding',
+        'mapping': derivative_holding_mapping
+    },
+    'derivative_transaction_ownership': {
+        'path': 'ownershipDocument.derivativeTable.derivativeTransaction',
+        'mapping': derivative_transaction_mapping
+    },
+    'reporting_owner_ownership': {
+        'path': 'ownershipDocument.reportingOwner',
+        'mapping': reporting_owner_mapping
+    },
+    'owner_signature_ownership': {
+        'path': 'ownershipDocument.ownerSignature',
+        'mapping': owner_signature_mapping
+    },
+    'metadata_ownership': {
+        'path': 'ownershipDocument',
+        'mapping': metadata_mapping
+    }
+}

datamule/document/{mappings/proxy_voting_record.py → tables/tables_proxyvotingrecord.py}

@@ -14,4 +14,11 @@ proxy_voting_record_dict = {
     'isin': 'isin',
     'voteSource': 'voteSource',
     'voteSeries': 'voteSeries'
+}
+
+config_proxyvotingrecord = {
+    'proxyvotingrecord': {
+        'path': 'proxyVoteTable.proxyTable',
+        'mapping': proxy_voting_record_dict
+    }
 }

datamule/document/{mappings/sbsef.py → tables/tables_sbsef.py}

@@ -11,3 +11,10 @@ sbsef_dict = {
     'filerInfo_liveTestFlag': 'liveTestFlag',
     'submissionType': 'submissionType'
 }
+
+config_sbsef = {
+   'sbsef': {
+       'path': 'edgarSubmission',
+       'mapping': sbsef_dict
+   }
+}

datamule/document/{mappings/sdr.py → tables/tables_sdr.py}

@@ -61,3 +61,10 @@ sdr_dict = {
     'headerData_filerInfo_liveTestFlag': 'headerLiveTestFlag',
     'headerData_submissionType': 'headerSubmissionType'
 }
+
+config_sdr = {
+   'sdr': {
+       'path': 'edgarSubmission',
+       'mapping': sdr_dict
+   }
+}

datamule/document/tables/utils.py

@@ -0,0 +1,26 @@
+def safe_get(d, keys, default=None):
+    """Safely access nested dictionary keys"""
+    current = d
+    for key in keys:
+        if isinstance(current, dict) and key in current:
+            current = current[key]
+        else:
+            return default
+    return current
+
+# may modify this in the future to better account for lsits
+def flatten_dict(d, parent_key=''):
+    items = {}
+
+    if isinstance(d, list):
+        return [flatten_dict(item) for item in d]
+            
+    for k, v in d.items():
+        new_key = f"{parent_key}_{k}" if parent_key else k
+        
+        if isinstance(v, dict):
+            items.update(flatten_dict(v, new_key))
+        else:
+            items[new_key] = str(v)
+                
+    return items

datamule/submission.py

@@ -20,8 +20,8 @@ class Submission:
         
 
         # declare vars to be filled later
-        self.xbrl = None
-        self.fundamentals = None
+        self._xbrl = None
+        self._fundamentals_cache = {}
         
         # Validate parameters
         param_count = sum(x is not None for x in [path, sgml_content, batch_tar_path,url])
@@ -248,31 +248,46 @@ class Submission:
                 yield self._load_document_by_index(idx)
 
     def parse_xbrl(self):
-        if self.xbrl:
+        if self._xbrl:
             return
         
         for idx, doc in enumerate(self.metadata.content['documents']):
             if doc['type'] in ['EX-100.INS','EX-101.INS']:
                 document = self._load_document_by_index(idx)
-                self.xbrl = parse_inline_xbrl(content=document.content,file_type='extracted_inline')
+                self._xbrl = parse_inline_xbrl(content=document.content,file_type='extracted_inline')
                 return
 
             if doc['filename'].endswith('_htm.xml'):
                 document = self._load_document_by_index(idx)
-                self.xbrl = parse_inline_xbrl(content=document.content,file_type='extracted_inline')
+                self._xbrl = parse_inline_xbrl(content=document.content,file_type='extracted_inline')
                 return
 
+    @property
+    def xbrl(self):
+        if self._xbrl is None:
+            self.parse_xbrl()
+        return self._xbrl
         
-    def parse_fundamentals(self,categories=None):
-        self.parse_xbrl()
+    def parse_fundamentals(self, categories=None):
+        # Create cache key based on categories
+        categories_key = tuple(sorted(categories)) if categories else 'all'
+        
+        # Return cached result if available
+        if categories_key in self._fundamentals_cache:
+            return self._fundamentals_cache[categories_key]
+        
+        # Use the property to trigger XBRL parsing if needed
+        xbrl_data = self.xbrl
 
-        # if no xbrl return
-        if not self.xbrl:
-            return
+        # if no xbrl return None
+        if not xbrl_data:
+            self._fundamentals_cache[categories_key] = None
+            return None
+            
         # Transform XBRL records into the format needed by construct_fundamentals
         xbrl = []
         
-        for xbrl_record in self.xbrl:
+        for xbrl_record in xbrl_data:
             try:
                 # Extract basic fields
                 value = xbrl_record.get('_val', None)
@@ -322,6 +337,26 @@ class Submission:
                             end_date_key='period_end_date',
                             categories=categories)
         
-        self.fundamentals = fundamentals
+        # Cache the result
+        self._fundamentals_cache[categories_key] = fundamentals
+        return fundamentals
+
+    @property
+    def fundamentals(self):
+        """Get all fundamental data"""
+        return self.parse_fundamentals(categories=None)
+
+    def __getattr__(self, name):
+        # Check if it's a fundamentals property request
+        if name.endswith('_fundamentals'):
+            category = name.replace('_fundamentals', '')
+            return self.parse_fundamentals(categories=[category])
         
+        # For any other unknown attribute, try it as a fundamentals category
+        # Let parse_fundamentals handle whether it's valid or not
+        result = self.parse_fundamentals(categories=[name])
+        if result is not None:
+            return result
         
+        # Only raise AttributeError if parse_fundamentals returns None/empty
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")

{datamule-2.0.5.dist-info → datamule-2.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamule
-Version: 2.0.5
+Version: 2.0.6
 Summary: Work with SEC submissions at scale.
 Home-page: https://github.com/john-friedman/datamule-python
 Author: John Friedman

{datamule-2.0.5.dist-info → datamule-2.0.6.dist-info}/RECORD

@@ -6,7 +6,7 @@ datamule/package_updater.py,sha256=Z9zaa_y0Z5cknpRn8oPea3gg4kquFHfpfhduKKCZ6NU,9
 datamule/portfolio.py,sha256=YViG1JgJ9SFhg8N3tOOhBI8oc6Pmi2vwnHeHmlkC_5U,12119
 datamule/portfolio_compression_utils.py,sha256=8OPYEN5zAdV1FiTxgVN3S7cTKs99Elv74bwgoIJP4QY,12654
 datamule/sheet.py,sha256=Ws_YRtpvewLVioarngVMe8cgG_sp11MP9_goGbRaiWE,23952
-datamule/submission.py,sha256=qcb5TogrB2q6x4zcGPKFf4dkrAy0bAPzY71Ops_xW44,14437
+datamule/submission.py,sha256=tX1r-KeytnvZRcyeVeBVOS9KbT0baOs7eOgE9qGPU0g,15918
 datamule/data/listed_filer_metadata.csv,sha256=dT9fQ8AC5P1-Udf_UF0ZkdXJ88jNxJb_tuhi5YYL1rc,2426827
 datamule/datamule/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datamule/datamule/datamule_lookup.py,sha256=e8djAg-ctSyHiKk7BjbtgugZ3p8roUjzsym5z3AihUg,9468
@@ -14,33 +14,18 @@ datamule/datamule/datamule_mysql_rds.py,sha256=P5vL3RJnOwLz25hPKuoYmxSX7XeDe83YE
 datamule/datamule/downloader.py,sha256=aTyVUuIwynPtHB0Z9BvCasy9Ao5wfHptNAsjN-7yDTk,18525
 datamule/datamule/sec_connector.py,sha256=VwOaODpHoAWy8JIky6kLR1-orW_PB61RHw7pIGRpkow,3288
 datamule/document/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datamule/document/document.py,sha256=U9hSXT2Y06prM6sPcUU6uziV1f4_BhaaGz3QXE5zveg,14034
-datamule/document/processing.py,sha256=jDCEzBFDSQtq7nQxRScIsbALnFcvMPOkNkMUCa7mFxg,31921
-datamule/document/table.py,sha256=73yUJKY82ap32jhLmZeTti-jQ_lyhcJGlGwyxLtgYOg,12944
-datamule/document/mappings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datamule/document/mappings/atsn.py,sha256=qkZGNIhyPC3VTTOjQ8-FSCQIhUy4XeSycUGLShxNVCo,17743
-datamule/document/mappings/cfportal.py,sha256=bR9d6DDY0kJ_HGx_hND2y1PNNkZjemYZ2KdyFAcv760,25257
-datamule/document/mappings/d.py,sha256=ayRK-bTzelNH6fspp-n3gz6RXOrHVx6IjX-TmisrFe4,7714
-datamule/document/mappings/ex102_abs.py,sha256=FdGKvteRh_HsYgILF-8o4R6aSsjYwcaLpJxzdru4FTE,3976
-datamule/document/mappings/ex99a_sdr.py,sha256=PNdj9I0ZhNicPObLelNmjp33EgTwzvukqkBDnwxarE0,19
-datamule/document/mappings/ex99c_sdr.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datamule/document/mappings/ex99g_sdr.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datamule/document/mappings/ex99i_sdr.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datamule/document/mappings/information_table.py,sha256=6l2Via728I59RS0y9Pit37NoOSAbaT-vclArYxU1vtY,1585
-datamule/document/mappings/nmfp.py,sha256=WuTyM1SkBiiLVAHqFF4DTZ_8AvsIuonT2w7pwYDPTDw,17767
-datamule/document/mappings/npx.py,sha256=xwruBueC09kfWhXV3fNUnQWYwCWrdrhQoVO3cKfPTO4,6556
-datamule/document/mappings/onefourtyfour.py,sha256=_-w9h6wGINGH5pQqQvPrd0cgB5QfCtPG5M40ewf_w8Q,2604
-datamule/document/mappings/ownership.py,sha256=piD9vs4WFrB4yvp6c0pT5bibLKXgsM7hpnBUzaY0Xxs,10155
-datamule/document/mappings/proxy_voting_record.py,sha256=tSqLH065EOUq7U80P5GP1JBqipmAiqniPpP3E4adA1A,721
-datamule/document/mappings/sbs.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datamule/document/mappings/sbsef.py,sha256=Zw58rbYcnitynk1mh9g1jDrCfqmFlY60OEjPM6p9iF0,534
-datamule/document/mappings/schedule13.py,sha256=lh9sukpEte514Gid77Nz9zh3uBEFZEemrZ2Uau0qsgk,6295
-datamule/document/mappings/sdr.py,sha256=UekqZId5PFMMWRAJSaPvCpN4c1Hx-SLAQPEN8GW_Gbg,4829
-datamule/document/mappings/submission_metadata.py,sha256=pi1eW-tnoAQ6y3laRI29Op80E9BPqqmcfe45owKYStw,271
-datamule/document/mappings/ta.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datamule/document/mappings/thirteenfhr.py,sha256=XpYRIMPZnGLfEE4TqBI0BPXbyuq0xf3hut1fePOF6kU,4250
-datamule/document/mappings/twentyfivense.py,sha256=lKyj0ZBhkHX9gQJMTUPrQlxYFg3k-aBnWqtoS5bujZM,905
-datamule/document/mappings/twentyfourf2nt.py,sha256=Q7RPT3JgJHjYdjMuaSyAxclt6QPT_LgCQloxp-ByDuI,4118
+datamule/document/document.py,sha256=SMsofx2xmO92pGEM0lQt9cm7lxfuGT8WqcFvL4rxOVk,14406
+datamule/document/tables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/document/tables/tables.py,sha256=qGGMG2p85AKfS5uBY96m77qREyTtsA7BqfqjELT-x0U,4273
+datamule/document/tables/tables_13fhr.py,sha256=-6tWcaTyNsb0XuW0WMBrYir9Zn1wLZL0laKxRYfPNyg,4265
+datamule/document/tables/tables_25nse.py,sha256=kpoOcIpra6i3Wx_6pUCj1fkx0wUbMhx7pc8yUkrBJb4,980
+datamule/document/tables/tables_informationtable.py,sha256=L7qSNTiyr45iIa8z4gm7pKw_meHjIqMFc1SF5Y6XAGg,1658
+datamule/document/tables/tables_npx.py,sha256=tZDBAonAQWLsgecVK_OwIgNcUJhuV5L2gkTSNbXAgNE,6652
+datamule/document/tables/tables_ownership.py,sha256=pRoFFRGLWp8gKAAvvUbVRxIU2xDFAQhwi9bgwddsT8A,11185
+datamule/document/tables/tables_proxyvotingrecord.py,sha256=t5h6iQtlg28Rqt1NJ1FDHCFHFjj_4_aelnFbWLtQcs0,875
+datamule/document/tables/tables_sbsef.py,sha256=X6VKVnAdWxn2TgRmaAd1WWlxPhcLPQ-53s0qDokkPI0,635
+datamule/document/tables/tables_sdr.py,sha256=BwHRJvtijiYvNJ2lIc_30kct6VEmLimIzX28JjZBBqo,4924
+datamule/document/tables/utils.py,sha256=2-X_1NsiWj_XsD9djxCXwTeIVlg-ip78gG11xACJiDs,738
 datamule/mapping_dicts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datamule/mapping_dicts/html_mapping_dicts.py,sha256=G2PWB__FNg4VH9iFJFkflM0u-qOEtk67IWtGoqesb0k,5388
 datamule/mapping_dicts/txt_mapping_dicts.py,sha256=DQPrGYbAPQxomRUtt4iiMGrwuF7BHc_LeFBQuYBzU9o,6311
@@ -65,7 +50,7 @@ datamule/seclibrary/bq.py,sha256=C8sb_rpXTvchprrFLcbRar4Qi0XWW25tnv1YsHSS5o4,180
 datamule/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datamule/utils/construct_submissions_data.py,sha256=NB_hvfxlRXPyt4Fgc-5qA8vJRItkLhBedCSTaxwW7Jg,5887
 datamule/utils/format_accession.py,sha256=60RtqoNqoT9zSKVb1DeOv1gncJxzPTFMNW4SNOVmC_g,476
-datamule-2.0.5.dist-info/METADATA,sha256=UzOW91CX56mST6_QMXKrYeewjnylQc8_B0gyK7fcpc8,560
-datamule-2.0.5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-datamule-2.0.5.dist-info/top_level.txt,sha256=iOfgmtSMFVyr7JGl_bYSTDry79JbmsG4p8zKq89ktKk,9
-datamule-2.0.5.dist-info/RECORD,,
+datamule-2.0.6.dist-info/METADATA,sha256=j3-QjEqEptbptQCKn52ImVShwyjvurA0v-Bqt4aXel8,560
+datamule-2.0.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+datamule-2.0.6.dist-info/top_level.txt,sha256=iOfgmtSMFVyr7JGl_bYSTDry79JbmsG4p8zKq89ktKk,9
+datamule-2.0.6.dist-info/RECORD,,