datamule 1.2.2__py3-none-any.whl → 1.2.9__py3-none-any.whl

datamule/sec/submissions/monitor.py

@@ -1,130 +1,183 @@
+import time
+from collections import deque
+from datetime import datetime
+import xml.etree.ElementTree as ET
+import re
 import asyncio
-from datetime import datetime, timedelta
-from .eftsquery import EFTSQuery  # Import the class directly instead of the function
-from ..rss.monitor import start_monitor  # Import start_monitor directly
-import pytz
+from ..utils import headers, PreciseRateLimiter
+from .eftsquery import EFTSQuery
+import aiohttp
 
 
-async def _process_efts_hits(hits, collected_accession_numbers, data_callback=None,rate_limiter=None):
-    """Process EFTS hits, collect accession numbers, and call data callback."""
-    processed_hits = []
+async def poll_rss(limiter):
+    base_url = 'https://www.sec.gov/cgi-bin/browse-edgar?count=100&action=getcurrent&output=rss'
     
-    for hit in hits:
-        try:
-            source = hit.get('_source', {})
-            
-            # Extract key fields
-            accession_number = source.get('adsh')
-                
-            # Extract submission_type (form) and ciks
-            submission_type = source.get('form')
-            ciks = source.get('ciks', [])
-            ciks = [str(int(cik)) for cik in ciks]
-
-            filing_date = source.get('file_date')
-                
-            # Create standardized filing record
-            filing = {
-                'accession_number': accession_number,
-                'submission_type': submission_type,
-                'ciks': ciks,
-                'filing_date': filing_date,
-
-            }
-            
-            processed_hits.append(filing)
-            collected_accession_numbers.add(accession_number)  # Changed append to add for set operation
-            
-        except Exception as e:
-            print(f"Error processing EFTS hit: {e}")
+    # Create a session specifically for this RSS polling operation
+    async with aiohttp.ClientSession(headers=headers) as session:
+        # Use the rate limiter before making the request
+        async with limiter:
+            # Make the HTTP request with the session
+            async with session.get(base_url) as response:
+                content = await response.read()
     
-    # Call data callback if provided
-    if data_callback and processed_hits:
-        await data_callback(processed_hits, rate_limiter)
+    # Process the content
+    content_str = content.decode('utf-8')
+    root = ET.fromstring(content_str)
+    namespace = {'atom': 'http://www.w3.org/2005/Atom'}
+    entries = root.findall('atom:entry', namespace)
+    grouped = {}
+
+    for entry in entries:
+        url = entry.find('atom:link', namespace).get('href')
+        accession = re.search(r'/(\d{10})-(\d{2})-(\d{6})', url)
+        accession = accession.group(1) + accession.group(2) + accession.group(3)
+        cik = re.search(r'/data/(\d+)/', url).group(1)
         
-    return processed_hits
-
-async def _master_monitor_impl(data_callback=None, poll_callback=None, submission_type=None, cik=None, 
-                              polling_interval=200, requests_per_second=2.0, quiet=True, start_date=None):
-    """Implementation of the master monitor."""
-    # Set default start date to today if not provided (eastern)
-    eastern_tz = pytz.timezone('US/Eastern')
-    current_date = datetime.now(eastern_tz).strftime('%Y-%m-%d')
-    if not start_date:
-        start_date = current_date
+        if accession not in grouped:
+            grouped[accession] = {'submission_type': '', 'ciks': set(), 'filing_date': ''}
         
-    # Changed from list to set for more efficient lookups
-    collected_accession_numbers = set()
-    
-    if not quiet:
-        print(f"Starting SEC monitoring from {start_date}")
-    
-    # Step 1: Query EFTS for all filings from start_date up to current date
-    if not quiet:
-        print(f"Fetching filings from {start_date} to {current_date}...")
-    
-    # Prepare a wrapper callback to collect accession numbers
-    async def process_callback(hits):
-         await _process_efts_hits(hits, collected_accession_numbers, data_callback, efts_query.limiter)
-    
-    # Create an EFTSQuery instance
-    efts_query = EFTSQuery(requests_per_second=requests_per_second)
+        grouped[accession]['ciks'].add(cik)
+        grouped[accession]['submission_type'] = entry.find('atom:category', namespace).get('term')
+        summary_text = entry.find('atom:summary', namespace).text
+        filing_date_match = re.search(r'Filed:</b>\s*(\d{4}-\d{2}-\d{2})', summary_text)
+        if filing_date_match:
+            grouped[accession]['filing_date'] = filing_date_match.group(1)
+
+    results = [{'accession': int(k.replace('-', '')), 'submission_type': v['submission_type'], 'ciks': list(v['ciks']), 'filing_date': v['filing_date']} for k, v in grouped.items()]
+    return results
+
+def clean_efts_hits(hits):
+    # clean hits
+    hits = [{'accession': int(hit['_source']['adsh'].replace('-','')), 'filing_date': hit['_source']['file_date'], 'ciks': hit['_source']['ciks']} for hit in hits]
+    return hits
+
+class Monitor():
+    def __init__(self):
+        self.accessions = deque(maxlen=50000)
+        self.ratelimiters = {'sec.gov': PreciseRateLimiter(rate=5)}
+        self.efts_query = EFTSQuery(quiet=True)
+        self.efts_query.limiter = self.ratelimiters['sec.gov']
+
+    def set_domain_rate_limit(self, domain, rate):
+        self.ratelimiters[domain] = PreciseRateLimiter(rate=rate)
+        if domain == 'sec.gov':
+            self.efts_query.limiter = self.ratelimiters[domain]
     
-    # Run EFTS query for the date range
-    async with efts_query:
-        await efts_query.query(
-            cik=cik,
-            submission_type=submission_type,
-            filing_date=(start_date, current_date),
-            callback=process_callback
+    async def _async_run_efts_query(self, **kwargs):
+        """Async helper method to run EFTS query without creating a new event loop"""
+        # Make sure to set quiet parameter if provided in kwargs
+        self.efts_query.quiet = kwargs.get('quiet', True)
+        return await self.efts_query.query(
+            cik=kwargs.get('cik'), 
+            submission_type=kwargs.get('submission_type'),
+            filing_date=kwargs.get('filing_date'),
+            location=kwargs.get('location'),
+            callback=kwargs.get('callback'),
+            name=kwargs.get('name')
         )
+
+    async def _async_monitor_submissions(self, data_callback=None, interval_callback=None,
+                            polling_interval=1000, quiet=True, start_date=None,
+                            validation_interval=60000):
+        """
+        Async implementation of monitor_submissions.
+        """
+
+        # Backfill if start_date is provided
+        if start_date is not None:
+            today_date = datetime.now().date().strftime('%Y-%m-%d')
+            if not quiet:
+                print(f"Backfilling from {start_date} to {today_date}")
+
+            hits = clean_efts_hits(await self._async_run_efts_query(
+                filing_date=(start_date, today_date),
+                quiet=quiet
+            ))
+
+            new_hits = self._filter_new_accessions(hits)
+            if not quiet:
+                print(f"New submissions found: {len(new_hits)}")
+            if new_hits and data_callback:
+                data_callback(new_hits)
+
+        last_polling_time = time.time()
+        last_validation_time = last_polling_time
+        current_time = last_polling_time
+
+        while True:
+            # RSS polling
+            if not quiet:
+                print(f"Polling RSS feed")
+            results = await poll_rss(self.ratelimiters['sec.gov'])
+            new_results = self._filter_new_accessions(results)
+            if new_results:
+                if not quiet:
+                    print(f"Found {len(new_results)} new submissions via RSS")
+                if data_callback:
+                    data_callback(new_results)
+            
+            # EFTS validation
+            if validation_interval and (current_time - last_validation_time) >= validation_interval/1000:
+                # Get submissions from the last 24 hours for validation
+                today_date = datetime.now().strftime('%Y-%m-%d')
+                if not quiet:
+                    print(f"Validating submissions from {today_date}")
+
+                hits = clean_efts_hits(await self._async_run_efts_query(
+                    filing_date=(today_date, today_date),
+                    quiet=quiet
+                ))
+                
+                new_hits = self._filter_new_accessions(hits)
+                if new_hits:
+                    if not quiet:
+                        print(f"Found {len(new_hits)} new submissions via EFTS validation")
+                    if data_callback:
+                        data_callback(new_hits)
+                last_polling_time = time.time()
+                last_validation_time = current_time
+            
+            # Interval callback
+            if interval_callback:
+                interval_callback()
+
+            next_poll_time = last_polling_time + (polling_interval / 1000)
+            current_time = time.time()
+            time_to_sleep = max(0, next_poll_time - current_time)
+            await asyncio.sleep(time_to_sleep)
+            last_polling_time = next_poll_time
+
+
+    def monitor_submissions(self, data_callback=None, interval_callback=None,
+                            polling_interval=1000, quiet=True, start_date=None,
+                            validation_interval=60000):
+        """
+        Monitor SEC submissions using the EDGAR system.
+        :param data_callback: function to call with the data
+        :param interval_callback: function that executes between polls
+        :param polling_interval: interval between polls in milliseconds
+        :param quiet: if True, suppresses output
+        :param start_date: backfill start date in YYYY-MM-DD format
+        :param validation_interval: interval between validation in milliseconds
+
+        This function combines the speed of the RSS feed (fast, but misses some submissions) with the accuracy of the EFTS system.
+        """
+        # This is now a synchronous wrapper around the async implementation
+        return asyncio.run(self._async_monitor_submissions(
+            data_callback=data_callback,
+            interval_callback=interval_callback,
+            polling_interval=polling_interval,
+            quiet=quiet,
+            start_date=start_date,
+            validation_interval=validation_interval
+        ))
     
-    if not quiet:
-        print(f"Historical query complete. Collected {len(collected_accession_numbers)} accession numbers.")
-    
-    # Step 2: Hand off to RSS monitor with collected accession numbers
-    if not quiet:
-        print("Starting real-time RSS monitoring...")
-    
-    # Start RSS monitor with the set of accession numbers to skip (from EFTS)
-    # and an empty list for ongoing tracking
-    await start_monitor(
-        data_callback=data_callback,
-        poll_callback=poll_callback,
-        submission_type=submission_type,
-        cik=cik,
-        polling_interval=polling_interval,
-        requests_per_second=requests_per_second,
-        quiet=quiet,
-        known_accession_numbers=[],  # Start with an empty list for ongoing tracking
-        skip_initial_accession_numbers=collected_accession_numbers  # Pass the EFTS accession numbers as the skip list
-    )
-
-def monitor(data_callback=None, poll_callback=None, submission_type=None, cik=None, 
-           polling_interval=200, requests_per_second=2.0, quiet=True, start_date=None):
-    """
-    Monitor SEC filings by combining EFTS historical queries with real-time RSS monitoring.
-    
-    Parameters:
-        data_callback (callable): Async function to call when new filings are found.
-                                 Will be called with a list of dicts containing
-                                 'accession_number', 'submission_type', and 'ciks'.
-        poll_callback (callable): Async function to call during RSS polling wait periods.
-        submission_type (str or list): Form type(s) to monitor (e.g., "8-K", "10-Q").
-        cik (str or list): CIK(s) to monitor.
-        polling_interval (int): Polling interval in milliseconds for RSS monitor.
-        requests_per_second (float): Maximum requests per second.
-        quiet (bool): Suppress verbose output.
-        start_date (str): ISO format date (YYYY-MM-DD) from which to start monitoring.
-                        If None, will start from current date. (EASTERN TIME)
-    """
-    return asyncio.run(_master_monitor_impl(
-        data_callback=data_callback,
-        poll_callback=poll_callback,
-        submission_type=submission_type,
-        cik=cik,
-        polling_interval=polling_interval,
-        requests_per_second=requests_per_second,
-        quiet=quiet,
-        start_date=start_date
-    ))
+    def _filter_new_accessions(self, items):
+        """Filter items to only include those with new accession numbers."""
+        new_items = []
+        for item in items:
+            accession = item['accession']
+            if accession not in self.accessions:
+                self.accessions.append(accession)
+                new_items.append(item)
+        return new_items

datamule/sec/submissions/textsearch.py

@@ -1,8 +1,4 @@
 import asyncio
-import aiohttp
-from datetime import datetime
-from urllib.parse import urlencode
-from tqdm import tqdm
 from .eftsquery import EFTSQuery
 
 class TextSearchEFTSQuery(EFTSQuery):

datamule/sec/xbrl/streamcompanyfacts.py

@@ -2,7 +2,7 @@ import asyncio
 import aiohttp
 import json
 from tqdm import tqdm
-from ..utils import PreciseRateLimiter, RateMonitor, RetryException, headers
+from ..utils import PreciseRateLimiter, RateMonitor, headers
 
 async def fetch_company_facts(session, cik, rate_limiter, rate_monitor, pbar):
     # Format CIK with leading zeros to 10 digits

datamule/seclibrary/downloader.py

@@ -1,7 +1,6 @@
 import os
 import asyncio
 import aiohttp
-from pathlib import Path
 from tqdm import tqdm
 import time
 import shutil
@@ -13,11 +12,12 @@ from concurrent.futures import ThreadPoolExecutor
 from functools import partial
 from queue import Queue, Empty
 from threading import Thread
-from secsgml import parse_sgml_submission
 from .query import query
 from os import cpu_count
 from ..submission import Submission
 
+
+
 class Downloader:
     def __init__(self, api_key=None):
         self.BASE_URL = "https://library.datamule.xyz/original/nc/"

datamule/submission.py

@@ -4,6 +4,70 @@ from .document.document import Document
 from secsgml import parse_sgml_submission_into_memory
 import os
 import aiofiles
+import tempfile
+
+
+# # NEW CODE YAY. probably will remove
+
+# def save_metadata_atomically(metadata_file_path, metadata_content):
+#     """Save metadata to a JSONL file atomically, works on any filesystem"""
+    
+#     # Create directory if it doesn't exist
+#     os.makedirs(os.path.dirname(metadata_file_path), exist_ok=True)
+    
+#     # Format the JSON with newline
+#     json_str = json.dumps(metadata_content, indent=4) + "\n"
+    
+#     # Write complete content to a temporary file first
+#     fd, temp_path = tempfile.mkstemp(dir=os.path.dirname(metadata_file_path))
+#     try:
+#         with os.fdopen(fd, 'w') as temp_file:
+#             temp_file.write(json_str)
+#             temp_file.flush()
+#             os.fsync(temp_file.fileno())  # Force write to disk
+        
+#         # Append the temporary file to the main file
+#         with open(metadata_file_path, 'a') as target_file:
+#             with open(temp_path, 'r') as temp_read:
+#                 content = temp_read.read()
+#                 target_file.write(content)
+#                 target_file.flush()
+#                 os.fsync(target_file.fileno())  # Force write to disk
+#     finally:
+#         # Clean up the temporary file
+#         if os.path.exists(temp_path):
+#             os.unlink(temp_path)
+
+# async def save_metadata_atomically_async(metadata_file_path, metadata_content):
+#     """Save metadata to a JSONL file atomically in async mode"""
+    
+#     # Create directory if it doesn't exist
+#     os.makedirs(os.path.dirname(metadata_file_path), exist_ok=True)
+    
+#     # Format the JSON with newline
+#     json_str = json.dumps(metadata_content, indent=4) + "\n"
+    
+#     # Write to a temporary file first
+#     fd, temp_path = tempfile.mkstemp(dir=os.path.dirname(metadata_file_path))
+#     os.close(fd)  # Close the file descriptor
+    
+#     try:
+#         async with aiofiles.open(temp_path, 'w') as temp_file:
+#             await temp_file.write(json_str)
+#             await temp_file.flush()
+        
+#         # Append the temporary file to the main file
+#         async with aiofiles.open(metadata_file_path, 'a') as target_file:
+#             async with aiofiles.open(temp_path, 'r') as temp_read:
+#                 content = await temp_read.read()
+#                 await target_file.write(content)
+#                 await target_file.flush()
+#     finally:
+#         # Clean up the temporary file
+#         if os.path.exists(temp_path):
+#             os.unlink(temp_path)
+
+# # END OF NEW CODE
 
 
 class Submission:
@@ -15,15 +79,17 @@ class Submission:
         
         if sgml_content is not None:
             self.path = None
-            self.metadata, raw_documents = parse_sgml_submission_into_memory(sgml_content)
+            metadata, raw_documents = parse_sgml_submission_into_memory(sgml_content)
+            self.metadata = Document(type='submission_metadata', content=metadata, extension='.json',filing_date=None,accession=None,path=None)
 
-            self.accession = self.metadata['accession-number']
-            self.filing_date= f"{self.metadata['filing-date'][:4]}-{self.metadata['filing-date'][4:6]}-{self.metadata['filing-date'][6:8]}"
+            # code dupe
+            self.accession = self.metadata.content['accession-number']
+            self.filing_date= f"{self.metadata.content['filing-date'][:4]}-{self.metadata.content['filing-date'][4:6]}-{self.metadata.content['filing-date'][6:8]}"
     
             self.documents = []
             filtered_metadata_documents = []
 
-            for idx,doc in enumerate(self.metadata['documents']):
+            for idx,doc in enumerate(self.metadata.content['documents']):
                 type = doc.get('type')
                 
                 # Keep only specified types
@@ -35,13 +101,19 @@ class Submission:
 
                 filtered_metadata_documents.append(doc)
             
-            self.metadata['documents'] = filtered_metadata_documents
+            self.metadata.content['documents'] = filtered_metadata_documents
 
         if path is not None:
             self.path = Path(path)  
             metadata_path = self.path / 'metadata.json'
             with metadata_path.open('r') as f:
-                self.metadata = json.load(f)
+                metadata = json.load(f) 
+            self.metadata = Document(type='submission_metadata', content=metadata, extension='.json',filing_date=None,accession=None,path=metadata_path)
+
+            # Code dupe
+            self.accession = self.metadata.content['accession-number']
+            self.filing_date= f"{self.metadata.content['filing-date'][:4]}-{self.metadata.content['filing-date'][4:6]}-{self.metadata.content['filing-date'][6:8]}"
+    
 
 
 
@@ -52,7 +124,7 @@ class Submission:
         else:
             document_types = document_type
 
-        for idx,doc in enumerate(self.metadata['documents']):
+        for idx,doc in enumerate(self.metadata.content['documents']):
             if doc['type'] in document_types:
                 
                 # if loaded from path
@@ -65,9 +137,12 @@ class Submission:
                     document_path = self.path / filename
                     extension = document_path.suffix
 
-                    with document_path.open('r') as f:
+                    with document_path.open('rb') as f:
                         content = f.read()
 
+                    if extension in ['.htm','.html','.txt','.xml']:
+                        content = content.decode('utf-8', errors='replace')
+
                     yield Document(type=doc['type'], content=content, extension=extension,filing_date=self.filing_date,accession=self.accession,path=document_path)
                 # if loaded from sgml_content
                 else:
@@ -75,7 +150,7 @@ class Submission:
 
     
     def __iter__(self):
-        for idx,doc in enumerate(self.metadata['documents']):
+        for idx,doc in enumerate(self.metadata.content['documents']):
             # if loaded from path
             if self.path is not None:
                 filename = doc.get('filename')
@@ -89,9 +164,12 @@ class Submission:
 
                 # check if the file exists
                 if document_path.exists():
-                    with document_path.open('r') as f:
+                    with document_path.open('rb') as f:
                         content = f.read()
 
+                    if extension in ['.htm','.html','.txt','.xml']:
+                        content = content.decode('utf-8', errors='replace')
+
                     yield Document(type=doc['type'], content=content, extension=extension,filing_date=self.filing_date,accession=self.accession,path=document_path)
                 else:
                     print(f"Warning: File {document_path} does not exist likely due to keep types in downloading.")
@@ -100,28 +178,6 @@ class Submission:
             else:
                 yield self.documents[idx]
 
-    # keep documents by document type
-    def keep(self, document_type):
-        # Convert single document type to list for consistent handling
-        if isinstance(document_type, str):
-            document_types = [document_type]
-        else:
-            document_types = document_type
-
-        if self.path is not None:
-            for doc in self.metadata['documents']:
-                filename = doc.get('filename')
-                type = doc.get('type')
-                if type not in document_types:
-                    # oh we need handling here for sequences case
-                    if filename is None:
-                        filename = doc.sequence + '.txt'
-
-                    document_path = self.path / filename
-                    # delete the file
-                    document_path.unlink()
-        else:
-            print("Warning: keep() method is only available when loading from path.")
 
 
 
@@ -131,9 +187,9 @@ class Submission:
         
         metadata_path = file_dir / "metadata.json"
         with open(metadata_path, 'w') as f:
-            json.dump(self.metadata, f, indent=4)
+            json.dump(self.metadata.content, f, indent=4)
         
-        for idx, doc in enumerate(self.metadata['documents']):
+        for idx, doc in enumerate(self.metadata.content['documents']):
             try:
                 filename = doc.get('filename')
                 if filename is None:
@@ -172,9 +228,9 @@ class Submission:
         
         metadata_path = file_dir / "metadata.json"
         async with aiofiles.open(metadata_path, 'w') as f:
-            await f.write(json.dumps(self.metadata, indent=4))
+            await f.write(json.dumps(self.metadata.content, indent=4))
         
-        for idx, doc in enumerate(self.metadata['documents']):
+        for idx, doc in enumerate(self.metadata.content['documents']):
             try:
                 filename = doc.get('filename')
                 if filename is None:

{datamule-1.2.2.dist-info → datamule-1.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamule
-Version: 1.2.2
+Version: 1.2.9
 Summary: Making it easier to use SEC filings.
 Home-page: https://github.com/john-friedman/datamule-python
 Author: John Friedman
@@ -10,7 +10,6 @@ Requires-Dist: tqdm
 Requires-Dist: requests
 Requires-Dist: nest-asyncio
 Requires-Dist: aiofiles
-Requires-Dist: polars
 Requires-Dist: setuptools
 Requires-Dist: selectolax
 Requires-Dist: pytz

datamule-1.2.9.dist-info/RECORD

@@ -0,0 +1,62 @@
+datamule/__init__.py,sha256=glzwBeGJEE6-TG7mRule9GH6L59XaIRR9T7ALcdpMus,1067
+datamule/config.py,sha256=Y--CVv7JcgrjJkMOSLrvm2S8B9ost6RMSkGviP-MKtg,883
+datamule/helper.py,sha256=g9Kb1DWbViCoON06PjOkSX5Ucu0uG7zPwhsO2LQ6C1g,3579
+datamule/index.py,sha256=_7Ox5hyF_7RWdblVFr5rNyv_ARwBP7VY4f703pk9qQ8,2074
+datamule/package_updater.py,sha256=Z9zaa_y0Z5cknpRn8oPea3gg4kquFHfpfhduKKCZ6NU,958
+datamule/portfolio.py,sha256=8fiK-vfZM5-NJSvOEsDR2YDb-2njjzFk6l7BiRyrzOM,7168
+datamule/sheet.py,sha256=TvFqK9eAYuVoJ2uWdAlx5EN6vS9lke-aZf7FqtUiDBc,22304
+datamule/submission.py,sha256=Yh5nG3ioumhl6z30wJdIEmKjDDNSuo0r2xycZSIaeIg,11035
+datamule/document/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/document/document.py,sha256=menUFoeWwiY0rJnBkQiqY4NWnO0J17-qs8jFvO_1jiY,9969
+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/mapping_dicts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/mapping_dicts/txt_mapping_dicts.py,sha256=DQPrGYbAPQxomRUtt4iiMGrwuF7BHc_LeFBQuYBzU9o,6311
+datamule/mapping_dicts/xml_mapping_dicts.py,sha256=Z22yDVwKYonUfM5foQP00dVDE8EHhhMKp0CLqVKV5OI,438
+datamule/sec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/sec/utils.py,sha256=JUxwijJiqRMnRJNQzVUamyF5h9ZGc7RnO_zsLOIM73g,2079
+datamule/sec/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/sec/infrastructure/submissions_metadata.py,sha256=f1KarzFSryKm0EV8DCDNsBw5Jv0Tx5aljiGUJkk7DRk,18745
+datamule/sec/submissions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/sec/submissions/downloader.py,sha256=60wX2Yml1UCuxOtU0xMxqqeyHhrypCmlDQ0jZF-StJo,2665
+datamule/sec/submissions/eftsquery.py,sha256=mSZon8rlW8dxma7M49ZW5V02Fn-ENOdt9TNO6elBrhE,27983
+datamule/sec/submissions/monitor.py,sha256=s6uknn1dF1EemiI3Hl4nEq3txwK7nYl6wmayuUPYpRs,7844
+datamule/sec/submissions/streamer.py,sha256=EXyWNCD9N6mZmvm9lFSCFodF19zSQ8jfIbWPZNp0K5Y,11253
+datamule/sec/submissions/textsearch.py,sha256=zEr3NXdhVFL8eMh2jruVXIt7taUZTMdNy2hOAyRM2pA,5706
+datamule/sec/xbrl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/sec/xbrl/downloadcompanyfacts.py,sha256=rMWRiCF9ci_gNZMJ9MC2c_PGEd-yEthawQ0CtVwWTjM,3323
+datamule/sec/xbrl/filter_xbrl.py,sha256=g9OT4zrNS0tiUJeBIwbCs_zMisOBkpFnMR3tV4Tr39Q,1316
+datamule/sec/xbrl/streamcompanyfacts.py,sha256=Qq88PqW5_j1k3Aqrl0KRmKeF54D6Wbb6H5N2tbvKUzM,3307
+datamule/sec/xbrl/xbrlmonitor.py,sha256=TKFVfSyyUUfUgFQw4WxEVs4g8Nh-2C0tygNIRmTqW3Y,5848
+datamule/seclibrary/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/seclibrary/bq.py,sha256=C8sb_rpXTvchprrFLcbRar4Qi0XWW25tnv1YsHSS5o4,18025
+datamule/seclibrary/downloader.py,sha256=PIgz_7ASUTZOHcUZGcD1SmLaGSbq7xe7EiJT0Z7HU4M,13653
+datamule/seclibrary/query.py,sha256=qGuursTERRbOGfoDcYcpo4oWkW3PCBW6x1Qf1Puiak4,7352
+datamule-1.2.9.dist-info/METADATA,sha256=5bMwIRcARNqP6S1cdPzoIBuu1miiUJUUdWnTXvwtPNk,490
+datamule-1.2.9.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+datamule-1.2.9.dist-info/top_level.txt,sha256=iOfgmtSMFVyr7JGl_bYSTDry79JbmsG4p8zKq89ktKk,9
+datamule-1.2.9.dist-info/RECORD,,