datamule 1.0.8__py3-none-any.whl → 1.0.9__py3-none-any.whl

datamule/sec/xbrl/xbrlmonitor.py

@@ -0,0 +1,143 @@
+import asyncio
+import aiohttp
+import time
+from collections import deque
+from lxml import etree
+from ..utils import PreciseRateLimiter, headers
+
+class XBRLMonitor:
+    """
+    Monitor for SEC XBRL RSS feed.
+    Polls https://www.sec.gov/Archives/edgar/xbrlrss.all.xml for new XBRL filings.
+    """
+    
+    def __init__(self, requests_per_second=2.0):
+        """Initialize the XBRL Monitor."""
+        self.url = "https://www.sec.gov/Archives/edgar/xbrlrss.all.xml"
+        self.seen_accessions = deque(maxlen=2000)  # Store up to 2000 accession numbers
+        self.limiter = PreciseRateLimiter(requests_per_second)
+        self.headers = headers
+        self.running = False
+    
+    async def _fetch_rss(self, session):
+        """Fetch the XBRL RSS feed from SEC."""
+        async with self.limiter:
+            try:
+                async with session.get(self.url) as response:
+                    response.raise_for_status()
+                    return await response.text()
+            except Exception as e:
+                print(f"Error fetching RSS feed: {str(e)}")
+                return None
+    
+    def _parse_rss(self, xml_content):
+        """Parse the XBRL RSS feed XML content using lxml."""
+        # Parse XML using lxml
+        parser = etree.XMLParser(recover=True)
+        root = etree.fromstring(xml_content.encode('utf-8'), parser)
+        
+        # Define namespaces
+        namespaces = {
+            'edgar': 'https://www.sec.gov/Archives/edgar'
+        }
+        
+        entries = []
+        for item in root.findall('.//item'):
+            # Get basic information
+            title = item.find('title').text if item.find('title') is not None else ""
+            link = item.find('link').text if item.find('link') is not None else ""
+            
+            # Get EDGAR-specific information
+            edgar_filing = item.find('.//edgar:xbrlFiling', namespaces)
+            if edgar_filing is not None:
+                cik = edgar_filing.find('./edgar:cikNumber', namespaces).text if edgar_filing.find('./edgar:cikNumber', namespaces) is not None else ""
+                acc_number = edgar_filing.find('./edgar:accessionNumber', namespaces).text if edgar_filing.find('./edgar:accessionNumber', namespaces) is not None else ""
+                form_type = edgar_filing.find('./edgar:formType', namespaces).text if edgar_filing.find('./edgar:formType', namespaces) is not None else ""
+                
+                # Keep accession number with dashes
+                if acc_number:
+                    entries.append({
+                        'accession_number': acc_number,
+                        'cik': cik,
+                        'submission_type': form_type,
+                        'link': link
+                    })
+        
+        return entries
+        
+    
+    async def _poll_once(self, data_callback=None, quiet=True):
+        """Internal async implementation of poll_once."""
+        if not quiet:
+            print(f"Polling {self.url}")
+        
+        async with aiohttp.ClientSession(headers=self.headers) as session:
+            xml_content = await self._fetch_rss(session)
+            if not xml_content:
+                return []
+            
+            all_entries = self._parse_rss(xml_content)
+            new_entries = []
+            
+            # Filter out entries we've already seen
+            for entry in all_entries:
+                if entry['accession_number'] not in self.seen_accessions:
+                    self.seen_accessions.appendleft(entry['accession_number'])
+                    new_entries.append(entry)
+
+            if new_entries and not quiet:
+                print(f"Found {len(new_entries)} new XBRL filings")
+            
+            # Call the callback if provided and if we have new entries
+            if new_entries and data_callback:
+                await data_callback(new_entries)
+            
+            return new_entries
+    
+    def poll_once(self, data_callback=None, quiet=True):
+        """
+        Poll the XBRL RSS feed once and process new filings.
+        Synchronous wrapper around async implementation.
+        """
+        return asyncio.run(self._poll_once(data_callback, quiet))
+    
+    async def _monitor(self, data_callback=None, poll_callback=None, polling_interval=600000, quiet=True):
+        """Internal async implementation of monitor."""
+        self.running = True
+        while self.running:
+            try:
+                # Poll once for new filings
+                await self._poll_once(data_callback, quiet)
+                
+                # Execute polling callback if provided
+                start_wait = time.time()
+                if poll_callback:
+                    try:
+                        await poll_callback()
+                    except Exception as e:
+                        print(f"Error in poll callback: {str(e)}")
+                
+                # Sleep for the remaining interval time
+                elapsed = (time.time() - start_wait) * 1000
+                if elapsed < polling_interval:
+                    await asyncio.sleep((polling_interval - elapsed) / 1000)
+                
+            except Exception as e:
+                print(f"Error in monitoring: {str(e)}")
+                await asyncio.sleep(polling_interval / 1000)
+    
+    def monitor(self, data_callback=None, poll_callback=None, polling_interval=600000, quiet=True):
+        """
+        Continuously poll the XBRL RSS feed at the specified interval.
+        Synchronous wrapper around async implementation.
+        """
+        return asyncio.run(self._monitor(
+            data_callback=data_callback,
+            poll_callback=poll_callback,
+            polling_interval=polling_interval,
+            quiet=quiet
+        ))
+    
+    def stop(self):
+        """Stop the continuous polling."""
+        self.running = False

datamule/seclibrary/downloader.py

@@ -0,0 +1,286 @@
+import os
+import asyncio
+import aiohttp
+from pathlib import Path
+from tqdm import tqdm
+import time
+import shutil
+import ssl
+import zstandard as zstd
+import io
+import json
+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
+
+class Downloader:
+    def __init__(self, api_key=None):
+        self.BASE_URL = "https://library.datamule.xyz/original/nc/"
+        self.CHUNK_SIZE = 2 * 1024 * 1024
+        self.MAX_CONCURRENT_DOWNLOADS = 250
+        self.MAX_DECOMPRESSION_WORKERS = cpu_count()
+        self.MAX_PROCESSING_WORKERS = cpu_count()
+        self.QUEUE_SIZE = 10
+        if api_key is not None:
+            self._api_key = api_key
+
+    @property
+    def api_key(self):
+        return getattr(self, '_api_key', None) or os.getenv('DATAMULE_API_KEY')
+
+    @api_key.setter
+    def api_key(self, value):
+        if not value:
+            raise ValueError("API key cannot be empty")
+        self._api_key = value
+
+    def _log_error(self, output_dir, filename, error_msg):
+        error_file = os.path.join(output_dir, 'errors.json')
+        try:
+            if os.path.exists(error_file):
+                with open(error_file, 'r') as f:
+                    errors = json.load(f)
+            else:
+                errors = {}
+            
+            errors[filename] = str(error_msg)
+            
+            with open(error_file, 'w') as f:
+                json.dump(errors, f, indent=2)
+        except Exception as e:
+            print(f"Failed to log error to {error_file}: {str(e)}")
+
+    class FileProcessor:
+        def __init__(self, output_dir, max_workers, queue_size, pbar, downloader):
+            self.processing_queue = Queue(maxsize=queue_size)
+            self.should_stop = False
+            self.processing_workers = []
+            self.output_dir = output_dir
+            self.max_workers = max_workers
+            self.batch_size = 50
+            self.pbar = pbar
+            self.downloader = downloader
+
+        def start_processing_workers(self):
+            for _ in range(self.max_workers):
+                worker = Thread(target=self._processing_worker)
+                worker.daemon = True
+                worker.start()
+                self.processing_workers.append(worker)
+
+        def _process_file(self, item):
+            filename, content = item
+            try:
+                parse_sgml_submission(output_dir=self.output_dir, content=content)
+                self.pbar.update(1)
+            except Exception as e:
+                accession_dir = os.path.join(self.output_dir, filename.split('.')[0])  
+                if os.path.exists(accession_dir):
+                    shutil.rmtree(accession_dir)
+                self.downloader._log_error(self.output_dir, filename, str(e))
+
+        def _processing_worker(self):
+            batch = []
+            while not self.should_stop:
+                try:
+                    item = self.processing_queue.get(timeout=1)
+                    if item is None:
+                        break
+
+                    batch.append(item)
+
+                    if len(batch) >= self.batch_size or self.processing_queue.empty():
+                        for item in batch:
+                            self._process_file(item)
+                            self.processing_queue.task_done()
+                        batch = []
+
+                except Empty:
+                    if batch:
+                        for item in batch:
+                            self._process_file(item)
+                            self.processing_queue.task_done()
+                        batch = []
+
+        def stop_workers(self):
+            self.should_stop = True
+            for _ in self.processing_workers:
+                self.processing_queue.put(None)
+            for worker in self.processing_workers:
+                worker.join()
+
+    def decompress_stream(self, compressed_chunks, filename, output_dir, processor):
+        dctx = zstd.ZstdDecompressor()
+        try:
+            input_buffer = io.BytesIO(b''.join(compressed_chunks))
+            decompressed_content = io.BytesIO()
+            
+            with dctx.stream_reader(input_buffer) as reader:
+                shutil.copyfileobj(reader, decompressed_content)
+                
+            content = decompressed_content.getvalue().decode('utf-8')
+            processor.processing_queue.put((filename, content))
+            return True
+                
+        except Exception as e:
+            self._log_error(output_dir, filename, f"Decompression error: {str(e)}")
+            return False
+        finally:
+            try:
+                input_buffer.close()
+                decompressed_content.close()
+            except:
+                pass
+
+    def save_regular_file(self, chunks, filename, output_dir, processor):
+        try:
+            content = b''.join(chunks).decode('utf-8')
+            processor.processing_queue.put((filename, content))
+            return True
+                
+        except Exception as e:
+            self._log_error(output_dir, filename, f"Error saving file: {str(e)}")
+            return False
+
+    async def download_and_process(self, session, url, semaphore, decompression_pool, output_dir, processor):
+        async with semaphore:
+            chunks = []
+            filename = url.split('/')[-1]
+
+            api_key = self.api_key
+            if not api_key:
+                raise ValueError("No API key found. Please set DATAMULE_API_KEY environment variable or provide api_key in constructor")
+
+            try:
+                headers = {
+                    'Connection': 'keep-alive',
+                    'Accept-Encoding': 'gzip, deflate, br',
+                    'Authorization': f'Bearer {api_key}'
+                }
+                
+                async with session.get(url, headers=headers) as response:
+                    if response.status == 200:
+                        async for chunk in response.content.iter_chunked(self.CHUNK_SIZE):
+                            chunks.append(chunk)
+
+                        loop = asyncio.get_running_loop()
+                        if filename.endswith('.zst'):
+                            success = await loop.run_in_executor(
+                                decompression_pool,
+                                partial(self.decompress_stream, chunks, filename, output_dir, processor)
+                            )
+                        else:
+                            success = await loop.run_in_executor(
+                                decompression_pool,
+                                partial(self.save_regular_file, chunks, filename, output_dir, processor)
+                            )
+
+                        if not success:
+                            self._log_error(output_dir, filename, "Failed to process file")
+                    elif response.status == 401:
+                        self._log_error(output_dir, filename, "Authentication failed: Invalid API key")
+                        raise ValueError("Invalid API key")
+                    else:
+                        self._log_error(output_dir, filename, f"Download failed: Status {response.status}")
+            except Exception as e:
+                self._log_error(output_dir, filename, str(e))
+
+    async def process_batch(self, urls, output_dir):
+        os.makedirs(output_dir, exist_ok=True)
+        
+        with tqdm(total=len(urls), desc="Processing files") as pbar:
+            processor = self.FileProcessor(output_dir, self.MAX_PROCESSING_WORKERS, self.QUEUE_SIZE, pbar, self)
+            processor.start_processing_workers()
+
+            semaphore = asyncio.Semaphore(self.MAX_CONCURRENT_DOWNLOADS)
+            decompression_pool = ThreadPoolExecutor(max_workers=self.MAX_DECOMPRESSION_WORKERS)
+
+            connector = aiohttp.TCPConnector(
+                limit=self.MAX_CONCURRENT_DOWNLOADS,
+                force_close=False,
+                ssl=ssl.create_default_context(),
+                ttl_dns_cache=300,
+                keepalive_timeout=60
+            )
+
+            # timeout should be max 30s.
+            async with aiohttp.ClientSession(connector=connector, timeout=aiohttp.ClientTimeout(total=30)) as session:
+                tasks = [self.download_and_process(session, url, semaphore, decompression_pool, output_dir, processor) for url in urls]
+                await asyncio.gather(*tasks, return_exceptions=True)
+
+            processor.processing_queue.join()
+            processor.stop_workers()
+            decompression_pool.shutdown()
+
+    def download(self, submission_type=None, cik=None, filing_date=None, output_dir="downloads", accession_numbers=None):
+        """
+        Query SEC filings and download/process them.
+        
+        Parameters:
+        - submission_type: Filing type(s), string or list (e.g., '10-K', ['10-K', '10-Q'])
+        - cik: Company CIK number(s), string, int, or list
+        - filing_date: Filing date(s), string, list, or tuple of (start_date, end_date)
+        - output_dir: Directory to save downloaded files
+        """
+        if self.api_key is None:
+            raise ValueError("No API key found. Please set DATAMULE_API_KEY environment variable or provide api_key in constructor")
+
+        # Query the SEC filings first - before starting any async operations
+        print("Querying SEC filings...")
+        filings = query(
+            submission_type=submission_type,
+            cik=cik,
+            filing_date=filing_date,
+            api_key=self.api_key
+        )
+        # After querying but before generating URLs
+        if accession_numbers:
+            filings = [filing for filing in filings if filing['accession_number'] in accession_numbers]
+        
+        # Generate URLs from the query results
+        
+        print(f"Generating URLs for {len(filings)} filings...")
+        urls = []
+        for item in filings:
+            url = f"{self.BASE_URL}{str(item['accession_number']).zfill(18)}.sgml"
+            if item['compressed'] == True or item['compressed'] == 'true' or item['compressed'] == 'True':
+                url += '.zst'
+            urls.append(url)
+        
+        if not urls:
+            print("No submissions found matching the criteria")
+            return
+
+        # Remove duplicates
+        urls = list(set(urls))
+        
+        # Now start the async processing
+        start_time = time.time()
+        
+        # Process the batch asynchronously
+        asyncio.run(self.process_batch(urls, output_dir))
+        
+        # Calculate and display performance metrics
+        elapsed_time = time.time() - start_time
+        print(f"\nProcessing completed in {elapsed_time:.2f} seconds")
+        print(f"Processing speed: {len(urls)/elapsed_time:.2f} files/second")
+
+
+def download(submission_type=None, cik=None, filing_date=None, api_key=None, output_dir="downloads", accession_numbers=None):
+    if accession_numbers:
+        accession_numbers = [int(str(x).replace('-', '')) for x in accession_numbers]
+    # check if acc no is empty list
+    elif accession_numbers == []:
+        raise ValueError("Applied filter resulted in empty accession numbers list")
+    downloader = Downloader(api_key=api_key)
+    downloader.download(
+        submission_type=submission_type,
+        cik=cik,
+        filing_date=filing_date,
+        output_dir=output_dir,
+        accession_numbers=accession_numbers
+    )

datamule/seclibrary/query.py

@@ -0,0 +1,181 @@
+import os
+import asyncio
+import aiohttp
+import urllib.parse
+import ssl
+import json
+import time
+from tqdm import tqdm
+
+class Query:
+    def __init__(self, api_key=None):
+        self.API_BASE_URL = "https://sec-library.jgfriedman99.workers.dev/"
+        self._api_key = api_key
+        self.total_cost = 0
+        self.remaining_balance = None
+        self.start_time = None
+
+    @property
+    def api_key(self):
+        return getattr(self, '_api_key', None) or os.getenv('DATAMULE_API_KEY')
+
+    @api_key.setter
+    def api_key(self, value):
+        if not value:
+            raise ValueError("API key cannot be empty")
+        self._api_key = value
+
+    async def _fetch_page(self, session, submission_type=None, cik=None, filing_date=None, page=1):
+        params = {
+            'api_key': self.api_key,
+            'page': page
+        }
+        
+        # Handle submission_type parameter
+        if submission_type:
+            if isinstance(submission_type, list):
+                params['submission_type'] = ','.join(str(x) for x in submission_type)
+            else:
+                params['submission_type'] = str(submission_type)
+        
+        # Handle CIK parameter
+        if cik:
+            if isinstance(cik, list):
+                params['cik'] = ','.join(str(x) for x in cik)
+            else:
+                params['cik'] = str(cik)
+        
+        # Handle filing_date parameter
+        if filing_date:
+            if isinstance(filing_date, tuple):
+                params['startdt'] = str(filing_date[0])
+                params['enddt'] = str(filing_date[1])
+            else:
+                if isinstance(filing_date, list):
+                    params['filing_date'] = ','.join(str(x) for x in filing_date)
+                else:
+                    params['filing_date'] = str(filing_date)
+
+        url = f"{self.API_BASE_URL}?{urllib.parse.urlencode(params)}"
+        
+        async with session.get(url) as response:
+            data = await response.json()
+            if not data.get('success'):
+                raise ValueError(f"API request failed: {data.get('error')}")
+            
+            # Track costs and balance
+            charges = data['metadata']['billing']['charges']
+            page_cost = charges['total']
+            self.total_cost += page_cost
+            self.remaining_balance = data['metadata']['billing']['remaining_balance']
+            
+            return data['data'], data['metadata']['pagination'], page_cost
+
+    async def execute_query(self, submission_type=None, cik=None, filing_date=None):
+        if self.api_key is None:
+            raise ValueError("No API key found. Please set DATAMULE_API_KEY environment variable or provide api_key in constructor")
+        
+        self.start_time = time.time()
+        total_items = 0
+        pages_processed = 0
+        
+        # Display query parameters
+        query_desc = []
+        if cik:
+            query_desc.append(f"CIK={cik}")
+        if submission_type:
+            query_desc.append(f"Type={submission_type}")
+        if filing_date:
+            if isinstance(filing_date, tuple):
+                query_desc.append(f"Date={filing_date[0]} to {filing_date[1]}")
+            else:
+                query_desc.append(f"Date={filing_date}")
+        
+        if query_desc:
+            print(f"QUERY: {', '.join(query_desc)}")
+        
+        connector = aiohttp.TCPConnector(ssl=ssl.create_default_context())
+        async with aiohttp.ClientSession(connector=connector) as session:
+            # Initialize progress bar with a custom format to avoid extra colons
+            pbar = tqdm(unit="page", bar_format="{desc}: {n_fmt} {unit} [{elapsed}<{remaining}, {rate_fmt}{postfix}]")
+            pbar.set_description("Fetching data")
+            
+            current_page = 1
+            has_more = True
+            results = []
+            
+            while has_more:
+                # Fetch page
+                page_results, pagination, page_cost = await self._fetch_page(session, 
+                                                                    submission_type=submission_type, 
+                                                                    cik=cik, 
+                                                                    filing_date=filing_date, 
+                                                                    page=current_page)
+                
+                # Accumulate results
+                results.extend(page_results)
+                
+                pages_processed += 1
+                total_items += len(page_results)
+                
+                # Update progress bar with cleaner format
+                pbar.set_description(f"Fetching data (page {current_page})")
+                pbar.set_postfix_str(f"cost=${self.total_cost:.2f} | balance=${self.remaining_balance:.2f}")
+                pbar.update(1)
+                
+                # Check if we need to fetch more pages
+                has_more = pagination.get('hasMore', False)
+                current_page += 1
+                
+                # For the first page, display record info using pbar.write instead of print
+                if pages_processed == 1:
+                    records_per_page = pagination.get('currentPageRecords', len(page_results))
+                    total_records = pagination.get('totalRecords', None)
+                    if total_records:
+                        pbar.write(f"Retrieved {records_per_page} records (page 1) of {total_records} total - Fetching additional pages...")
+                    else:
+                        pbar.write(f"Retrieved {records_per_page} records (page 1) - Fetching additional pages...")
+            
+            pbar.close()
+            
+            # Final summary
+            elapsed_time = time.time() - self.start_time
+            print("\nQuery complete:")
+            print(f"- Retrieved {total_items} filings across {pages_processed} pages")
+            print(f"- Total cost: ${self.total_cost:.2f}")
+            print(f"- Remaining balance: ${self.remaining_balance:.2f}")
+            print(f"- Time: {elapsed_time:.1f} seconds")
+            
+            return results
+
+
+def query(cik=None, submission_type=None, filing_date=None, api_key=None):
+    """
+    Query SEC filings data with optional filtering
+    
+    Parameters:
+    - cik: Company CIK number(s), can be string, int, or list
+    - submission_type: Filing type(s), can be string or list (e.g., '10-K', ['10-K', '10-Q'])
+    - filing_date: Filing date(s), can be string, list, or tuple of (start_date, end_date)
+    - api_key: Optional API key (can also use DATAMULE_API_KEY environment variable)
+    
+    Returns:
+    - List of all matching submission data
+    """
+    # Create a Query instance for this request
+    q = Query(api_key=api_key)
+    # remove dash from filing_date
+    if isinstance(filing_date, tuple):
+        filing_date = (filing_date[0].replace('-', ''), filing_date[1].replace('-', ''))
+    elif isinstance(filing_date, str):
+        filing_date = filing_date.replace('-', '')
+    elif isinstance(filing_date, list):
+        filing_date = [x.replace('-', '') for x in filing_date]
+
+    print(filing_date)
+    # Run the query and return results
+    return asyncio.run(q.execute_query(
+        submission_type=submission_type,
+        cik=cik,
+        filing_date=filing_date
+    ))

{datamule-1.0.8.dist-info → datamule-1.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamule
-Version: 1.0.8
+Version: 1.0.9
 Summary: Making it easier to use SEC filings.
 Home-page: https://github.com/john-friedman/datamule-python
 Author: John Friedman

datamule-1.0.9.dist-info/RECORD

@@ -0,0 +1,35 @@
+datamule/__init__.py,sha256=0npnB3i2F7YB7etG315oDiCd-eMo-A6MP5LX2gQclHY,914
+datamule/config.py,sha256=Y--CVv7JcgrjJkMOSLrvm2S8B9ost6RMSkGviP-MKtg,883
+datamule/document.py,sha256=BC8jdVy9pMOA9ghIqV5N2XJidmVNThqbBohsuSAnVoY,10813
+datamule/helper.py,sha256=xgOVnea-lUlQ5I-U0vYUp0VeKPNZehNhqjJvegA3lYE,3342
+datamule/portfolio.py,sha256=JmZlTrom_g7FXKXxWp_CiQTyC7p6_cDP08G0kFUja48,6982
+datamule/submission.py,sha256=JsxYlEz1Ywu6eC32OS15p4p-p8qB6SWd_rXuf2p5UfY,1247
+datamule/book/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/book/book.py,sha256=QWiowVNqb84o-JcVo0fpKumxnIbBge2ZeKwHxqkVMqw,1023
+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=zsSYmvYLZ7KS_MVDsg-j9Y4qeOyDOaHOQ6ZR6MpiET8,17520
+datamule/sec/rss/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/sec/rss/monitor.py,sha256=6r4EYaSlGu6VYErlj9zXJsIMLVie1cfacSZU-ESfuBI,18231
+datamule/sec/submissions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/sec/submissions/downloader.py,sha256=HxbSkNotLLW6ROmU30rnXPlCo9gY3SoB1Z4ZWvj9FIY,2669
+datamule/sec/submissions/eftsquery.py,sha256=h3MEkYWTrr_Dy76HzQnUvV-nQzi9b-B2CrW-5ah9WQ8,21892
+datamule/sec/submissions/monitor.py,sha256=XkwH5nvzr_dNttmFRQ52m7344IKbOtWDfOZIEdie4H8,5234
+datamule/sec/submissions/streamer.py,sha256=hc61le7gGIIWp1KEaOv_PhriUxf7YYFkQrSKELlZ3pg,9748
+datamule/sec/submissions/textsearch.py,sha256=4TTw-ceEu3_A4GktBDbsqo5vCUnrjdRnKiaWtfQSV7A,4340
+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=WyJIwuy5mNMXWpx_IkhFzDMe9MOfQ-vNkWl_JzBzFmc,3323
+datamule/sec/xbrl/xbrlmonitor.py,sha256=TKFVfSyyUUfUgFQw4WxEVs4g8Nh-2C0tygNIRmTqW3Y,5848
+datamule/seclibrary/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamule/seclibrary/downloader.py,sha256=Zb1TxsIz887tO3MJVP66siYVtNus89ti-g9oZ6VywrM,11500
+datamule/seclibrary/query.py,sha256=qGuursTERRbOGfoDcYcpo4oWkW3PCBW6x1Qf1Puiak4,7352
+datamule-1.0.9.dist-info/METADATA,sha256=QhoFw_l9Rc-VaXuBG_JpgWkB-02wxg0C2MTCgWNU3uA,512
+datamule-1.0.9.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+datamule-1.0.9.dist-info/top_level.txt,sha256=iOfgmtSMFVyr7JGl_bYSTDry79JbmsG4p8zKq89ktKk,9
+datamule-1.0.9.dist-info/RECORD,,

datamule-1.0.8.dist-info/RECORD

@@ -1,10 +0,0 @@
-datamule/__init__.py,sha256=0npnB3i2F7YB7etG315oDiCd-eMo-A6MP5LX2gQclHY,914
-datamule/config.py,sha256=Y--CVv7JcgrjJkMOSLrvm2S8B9ost6RMSkGviP-MKtg,883
-datamule/document.py,sha256=BC8jdVy9pMOA9ghIqV5N2XJidmVNThqbBohsuSAnVoY,10813
-datamule/helper.py,sha256=xgOVnea-lUlQ5I-U0vYUp0VeKPNZehNhqjJvegA3lYE,3342
-datamule/portfolio.py,sha256=JmZlTrom_g7FXKXxWp_CiQTyC7p6_cDP08G0kFUja48,6982
-datamule/submission.py,sha256=JsxYlEz1Ywu6eC32OS15p4p-p8qB6SWd_rXuf2p5UfY,1247
-datamule-1.0.8.dist-info/METADATA,sha256=RQZAJygj51jptYJPCRPZ10r1I_PNALFqkdriHLeAHc4,512
-datamule-1.0.8.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-datamule-1.0.8.dist-info/top_level.txt,sha256=iOfgmtSMFVyr7JGl_bYSTDry79JbmsG4p8zKq89ktKk,9
-datamule-1.0.8.dist-info/RECORD,,