datamule 0.381__py3-none-any.whl → 1.0.0__py3-none-any.whl

datamule/mulebot/tools.py

@@ -1,82 +1,82 @@
-
-get_company_concept_tool = {
-        "type": "function",
-        "function": {
-            "name": "get_company_concept",
-            "description": "ONLY use this when explicitly asked to get company XBRL concepts or facts for a given ticker",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "ticker": {"type": "string", "description": "The ticker of the company to get facts for"}
-                },
-                "required": ["ticker"]
-            }
-        }
-    }
-
-identifier_to_cik_tool =     {
-        "type": "function",
-        "function": {
-            "name": "identifier_to_cik",
-            "description": "ONLY use this when explicitly asked to convert a company's ticker to a CIK.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "ticker": {"type": "string", "description": "The ticker to convert to a CIK"},
-                },
-                "required": ["ticker"]
-            }
-        }
-    }
-
-get_filing_urls_tool = {
-    "type": "function",
-    "function": {
-        "name": "get_filing_urls",
-        "description": "ONLY use this when explicitly asked to get URLs of filings for a given company or multiple",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "ticker": {"type": "string", "description": "Ticker symbol of the company. Can be a single ticker or a list of tickers."},
-                "form": {"type": "string", "description": "Form type to get (e.g., '10-K', '10-Q')"},
-                "date": {"type": "string", "description": "Date of the filing, can be a single date, a range, or a list of dates. Format: 'YYYY-MM-DD'. If range use a tuple of two dates."},
-            },
-            "required": ["ticker"]
-        }
-    }
-}
-
-find_filing_section_by_title_tool = {
-    "type": "function",
-    "function": {
-        "name": "find_filing_section_by_title",
-        "description": "ONLY use this when explicitly given a filing URL and told to find a specific section",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "url": {"type": "string", "description": "URL of the filing to parse"},
-                "title": {"type": "string", "description": "The section title to search for in the filing"}
-            },
-            "required": ["url","title"]
-        }
-    }
-}
-
-return_title_tool = {
-    "type": "function",
-    "function": {
-        "name": "return_title",
-        "description": "use this to select a title",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "title": {"type": "string", "description": "The title to return"}
-            },
-            "required": ["title"]
-        }
-    }
-}
-
-
-
-tools = [get_company_concept_tool, identifier_to_cik_tool, get_filing_urls_tool, find_filing_section_by_title_tool]
+
+get_company_concept_tool = {
+        "type": "function",
+        "function": {
+            "name": "get_company_concept",
+            "description": "ONLY use this when explicitly asked to get company XBRL concepts or facts for a given ticker",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "ticker": {"type": "string", "description": "The ticker of the company to get facts for"}
+                },
+                "required": ["ticker"]
+            }
+        }
+    }
+
+identifier_to_cik_tool =     {
+        "type": "function",
+        "function": {
+            "name": "identifier_to_cik",
+            "description": "ONLY use this when explicitly asked to convert a company's ticker to a CIK.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "ticker": {"type": "string", "description": "The ticker to convert to a CIK"},
+                },
+                "required": ["ticker"]
+            }
+        }
+    }
+
+get_filing_urls_tool = {
+    "type": "function",
+    "function": {
+        "name": "get_filing_urls",
+        "description": "ONLY use this when explicitly asked to get URLs of filings for a given company or multiple",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "ticker": {"type": "string", "description": "Ticker symbol of the company. Can be a single ticker or a list of tickers."},
+                "form": {"type": "string", "description": "Form type to get (e.g., '10-K', '10-Q')"},
+                "date": {"type": "string", "description": "Date of the filing, can be a single date, a range, or a list of dates. Format: 'YYYY-MM-DD'. If range use a tuple of two dates."},
+            },
+            "required": ["ticker"]
+        }
+    }
+}
+
+find_filing_section_by_title_tool = {
+    "type": "function",
+    "function": {
+        "name": "find_filing_section_by_title",
+        "description": "ONLY use this when explicitly given a filing URL and told to find a specific section",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "url": {"type": "string", "description": "URL of the filing to parse"},
+                "title": {"type": "string", "description": "The section title to search for in the filing"}
+            },
+            "required": ["url","title"]
+        }
+    }
+}
+
+return_title_tool = {
+    "type": "function",
+    "function": {
+        "name": "return_title",
+        "description": "use this to select a title",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "title": {"type": "string", "description": "The title to return"}
+            },
+            "required": ["title"]
+        }
+    }
+}
+
+
+
+tools = [get_company_concept_tool, identifier_to_cik_tool, get_filing_urls_tool, find_filing_section_by_title_tool]

datamule/packageupdater.py

@@ -0,0 +1,207 @@
+import asyncio
+import aiohttp
+import json
+import csv
+import os
+from pkg_resources import resource_filename
+from .helper import headers
+from .downloader.downloader import PreciseRateLimiter, RateMonitor
+
+class PackageUpdater:
+    def __init__(self):
+        self.limiter = PreciseRateLimiter(5)  # 5 requests per second
+        self.rate_monitor = RateMonitor()
+        self.headers = headers
+    
+    async def _fetch_json(self, session, url):
+        """Fetch JSON with rate limiting and monitoring."""
+        async with self.limiter:
+            try:
+                async with session.get(url) as response:
+                    response.raise_for_status()
+                    content = await response.read()
+                    await self.rate_monitor.add_request(len(content))
+                    return await response.json()
+            except Exception as e:
+                print(f"Error fetching {url}: {str(e)}")
+                return None
+
+    async def _update_company_tickers(self):
+        """Update company tickers data files."""
+        url = 'https://www.sec.gov/files/company_tickers.json'
+        
+        # Define file paths
+        json_file = resource_filename('datamule', 'data/company_tickers.json')
+        csv_file = resource_filename('datamule', 'data/company_tickers.csv')
+        
+        # Define temporary file paths
+        temp_json_file = json_file + '.temp'
+        temp_csv_file = csv_file + '.temp'
+
+        async with aiohttp.ClientSession(headers=self.headers) as session:
+            try:
+                data = await self._fetch_json(session, url)
+                if not data:
+                    raise Exception("Failed to fetch company tickers data")
+
+                # Save the raw JSON file
+                with open(temp_json_file, 'w') as f:
+                    json.dump(data, f, indent=4)
+                
+                # Convert to CSV
+                with open(temp_csv_file, 'w', newline='') as csvfile:
+                    fieldnames = ['cik', 'ticker', 'title']
+                    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                    writer.writeheader()
+                    for _, company in data.items():
+                        writer.writerow({
+                            'cik': str(company['cik_str']).zfill(10),
+                            'ticker': company['ticker'],
+                            'title': company['title']
+                        })
+
+                # Replace original files
+                for src, dst in [(temp_json_file, json_file), (temp_csv_file, csv_file)]:
+                    if os.path.exists(dst):
+                        os.remove(dst)
+                    os.rename(src, dst)
+
+                print(f"Company tickers successfully updated")
+                return True
+
+            except Exception as e:
+                print(f"Error updating company tickers: {str(e)}")
+                return False
+            
+            finally:
+                # Clean up temp files
+                for temp_file in [temp_json_file, temp_csv_file]:
+                    if os.path.exists(temp_file):
+                        try:
+                            os.remove(temp_file)
+                        except Exception as e:
+                            print(f"Warning: Could not remove {temp_file}: {str(e)}")
+
+    async def _process_metadata_batch(self, session, companies, metadata_writer, former_names_writer):
+        """Process a batch of companies for metadata updates."""
+        metadata_fields = [
+            'cik', 'name', 'entityType', 'sic', 'sicDescription', 'ownerOrg',
+            'insiderTransactionForOwnerExists', 'insiderTransactionForIssuerExists',
+            'tickers', 'exchanges', 'ein', 'description', 'website', 'investorWebsite',
+            'category', 'fiscalYearEnd', 'stateOfIncorporation', 'stateOfIncorporationDescription',
+            'phone', 'flags', 'mailing_street1', 'mailing_street2', 'mailing_city',
+            'mailing_stateOrCountry', 'mailing_zipCode', 'mailing_stateOrCountryDescription',
+            'business_street1', 'business_street2', 'business_city', 'business_stateOrCountry',
+            'business_zipCode', 'business_stateOrCountryDescription'
+        ]
+
+        tasks = []
+        for company in companies:
+            cik = company['cik']
+            url = f'https://data.sec.gov/submissions/CIK{str(cik).zfill(10)}.json'
+            tasks.append(self._fetch_json(session, url))
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        for company, result in zip(companies, results):
+            if isinstance(result, Exception) or not result:
+                print(f"Error processing CIK {company['cik']}: {str(result) if isinstance(result, Exception) else 'No data'}")
+                continue
+
+            try:
+                metadata = {field: result.get(field, '') for field in metadata_fields if field not in ['tickers', 'exchanges']}
+                metadata['cik'] = company['cik']
+                metadata['tickers'] = ','.join(result.get('tickers', []))
+                metadata['exchanges'] = ','.join(result.get('exchanges', []))
+
+                # Add address information
+                for address_type in ['mailing', 'business']:
+                    address = result.get('addresses', {}).get(address_type, {})
+                    for key, value in address.items():
+                        metadata[f'{address_type}_{key}'] = value if value is not None else ''
+
+                metadata_writer.writerow(metadata)
+
+                for former_name in result.get('formerNames', []):
+                    former_names_writer.writerow({
+                        'cik': company['cik'],
+                        'former_name': former_name['name'],
+                        'from_date': former_name['from'],
+                        'to_date': former_name['to']
+                    })
+
+            except Exception as e:
+                print(f"Error processing metadata for CIK {company['cik']}: {str(e)}")
+
+    async def _update_company_metadata(self):
+        """Update company metadata and former names files."""
+        metadata_file = resource_filename('datamule', 'data/company_metadata.csv')
+        former_names_file = resource_filename('datamule', 'data/company_former_names.csv')
+        
+        temp_metadata_file = metadata_file + '.temp'
+        temp_former_names_file = former_names_file + '.temp'
+
+        # Load current company tickers
+        with open(resource_filename('datamule', 'data/company_tickers.csv'), 'r') as f:
+            company_tickers = list(csv.DictReader(f))
+
+        metadata_fields = ['cik', 'name', 'entityType', 'sic', 'sicDescription', 'ownerOrg',
+                        'insiderTransactionForOwnerExists', 'insiderTransactionForIssuerExists',
+                        'tickers', 'exchanges', 'ein', 'description', 'website', 'investorWebsite',
+                        'category', 'fiscalYearEnd', 'stateOfIncorporation', 'stateOfIncorporationDescription',
+                        'phone', 'flags', 'mailing_street1', 'mailing_street2', 'mailing_city',
+                        'mailing_stateOrCountry', 'mailing_zipCode', 'mailing_stateOrCountryDescription',
+                        'business_street1', 'business_street2', 'business_city', 'business_stateOrCountry',
+                        'business_zipCode', 'business_stateOrCountryDescription']
+
+        former_names_fields = ['cik', 'former_name', 'from_date', 'to_date']
+
+        try:
+            async with aiohttp.ClientSession(headers=self.headers) as session:
+                with open(temp_metadata_file, 'w', newline='') as mf, \
+                     open(temp_former_names_file, 'w', newline='') as fnf:
+                    
+                    metadata_writer = csv.DictWriter(mf, fieldnames=metadata_fields)
+                    metadata_writer.writeheader()
+                    
+                    former_names_writer = csv.DictWriter(fnf, fieldnames=former_names_fields)
+                    former_names_writer.writeheader()
+
+                    # Process in batches of 10 companies
+                    batch_size = 10
+                    for i in range(0, len(company_tickers), batch_size):
+                        batch = company_tickers[i:i + batch_size]
+                        await self._process_metadata_batch(
+                            session, batch, metadata_writer, former_names_writer
+                        )
+
+            # Replace original files
+            for src, dst in [(temp_metadata_file, metadata_file), 
+                           (temp_former_names_file, former_names_file)]:
+                if os.path.exists(dst):
+                    os.remove(dst)
+                os.rename(src, dst)
+
+            print("Company metadata successfully updated")
+            return True
+
+        except Exception as e:
+            print(f"Error updating company metadata: {str(e)}")
+            return False
+
+        finally:
+            # Clean up temp files
+            for temp_file in [temp_metadata_file, temp_former_names_file]:
+                if os.path.exists(temp_file):
+                    try:
+                        os.remove(temp_file)
+                    except Exception as e:
+                        print(f"Warning: Could not remove {temp_file}: {str(e)}")
+
+    def update_company_tickers(self):
+        """Update company tickers data files."""
+        return asyncio.run(self._update_company_tickers())
+
+    def update_company_metadata(self):
+        """Update company metadata and former names files."""
+        return asyncio.run(self._update_company_metadata())

datamule/portfolio.py

@@ -0,0 +1,106 @@
+from pathlib import Path
+from tqdm import tqdm
+from concurrent.futures import ThreadPoolExecutor
+from .submission import Submission
+from .downloader.premiumdownloader import PremiumDownloader
+from .downloader.downloader import Downloader
+from .config import Config
+import os
+
+class Portfolio:
+    def __init__(self, path):
+        self.path = Path(path)
+        self.submissions = []
+        self.MAX_WORKERS = os.cpu_count() - 1 
+        
+        if self.path.exists():
+            self._load_submissions()
+    
+    def _load_submissions(self):
+        folders = [f for f in self.path.iterdir() if f.is_dir()]
+        print(f"Loading {len(folders)} submissions")
+        
+        def load_submission(folder):
+            try:
+                return Submission(folder)
+            except Exception as e:
+                print(f"Error loading submission from {folder}: {str(e)}")
+                return None
+        
+        with ThreadPoolExecutor(max_workers=self.MAX_WORKERS) as executor:
+            self.submissions = list(tqdm(
+                executor.map(load_submission, folders),
+                total=len(folders),
+                desc="Loading submissions"
+            ))
+            
+        # Filter out None values from failed submissions
+        self.submissions = [s for s in self.submissions if s is not None]
+        print(f"Successfully loaded {len(self.submissions)} submissions")
+
+    def process_submissions(self, callback):
+        """Process all submissions using a thread pool."""
+        with ThreadPoolExecutor(max_workers=self.MAX_WORKERS) as executor:
+            results = list(tqdm(
+                executor.map(callback, self.submissions),
+                total=len(self.submissions),
+                desc="Processing submissions"
+            ))
+            return results
+
+    def process_documents(self, callback):
+        """Process all documents using a thread pool."""
+        documents = [doc for sub in self.submissions for doc in sub]
+        
+        with ThreadPoolExecutor(max_workers=self.MAX_WORKERS) as executor:
+            results = list(tqdm(
+                executor.map(callback, documents),
+                total=len(documents),
+                desc="Processing documents"
+            ))
+            return results
+
+    def download_submissions(self, cik=None, ticker=None, submission_type=None, filing_date=None, provider=None):
+        if provider is None:
+            config = Config()
+            provider = config.get_default_source()
+
+        downloader = PremiumDownloader() if provider == 'datamule' else Downloader()
+        downloader.download_submissions(
+            output_dir=self.path,
+            cik=cik,
+            ticker=ticker,
+            submission_type=submission_type,
+            filing_date=filing_date
+        )
+        
+        # Reload submissions after download
+        self._load_submissions()
+
+    def __iter__(self):
+        return iter(self.submissions)
+    
+    def document_type(self, document_types):
+        """Filter documents by type(s)."""
+        if isinstance(document_types, str):
+            document_types = [document_types]
+            
+        for submission in self.submissions:
+            yield from submission.document_type(document_types)
+
+    def contains_string(self, pattern, document_types=None):
+        """Search for pattern in documents, with optional type filter."""
+        def check_document(document):
+            return document if document.contains_string(pattern) else None
+        
+        # Get documents, filtered by type if specified
+        documents = list(self.document_type(document_types)) if document_types else [
+            doc for sub in self.submissions for doc in sub
+        ]
+        
+        with ThreadPoolExecutor(max_workers=self.MAX_WORKERS) as executor:
+            results = executor.map(check_document, documents)
+            
+            for doc in tqdm(results, total=len(documents), desc=f"Searching for '{pattern}'"):
+                if doc is not None:
+                    yield doc

datamule/submission.py

@@ -0,0 +1,76 @@
+from pathlib import Path
+import json
+from .document import Document
+
+class Submission:
+    def __init__(self, path):
+        self.path = Path(path)
+        self._load_metadata()
+    
+    def _load_metadata(self):
+        metadata_path = self.path / 'metadata.json'
+        with metadata_path.open('r') as f:
+            self.metadata = json.load(f)
+            
+    def keep(self, document_types):
+        """Keep files of specified document types, delete others
+        Args:
+            document_types: string or list of strings representing document types to keep
+        """
+        # Convert single string to list for consistent handling
+        if isinstance(document_types, str):
+            document_types = [document_types]
+            
+        for doc in self.metadata['documents']:
+            filename = doc.get('filename')
+            if filename is None:
+                continue
+                
+            filepath = self.path / filename
+            # Delete if document type isn't in our keep list
+            if doc['type'] not in document_types and filepath.exists():
+                filepath.unlink()
+                
+    def drop(self, document_types):
+        """Delete files of specified document types, keep others
+        Args:
+            document_types: string or list of strings representing document types to drop
+        """
+        # Convert single string to list for consistent handling
+        if isinstance(document_types, str):
+            document_types = [document_types]
+            
+        for doc in self.metadata['documents']:
+            filename = doc.get('filename')
+            if filename is None:
+                continue
+                
+            filepath = self.path / filename
+            # Delete if document type is in our drop list
+            if doc['type'] in document_types and filepath.exists():
+                filepath.unlink()
+
+    def document_type(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
+
+        for doc in self.metadata['documents']:
+            if doc['type'] in document_types:
+                filename = doc.get('filename')
+                if filename is None:
+                    continue
+                    
+                document_path = self.path / filename
+                yield Document(doc['type'], document_path)
+    
+    def __iter__(self):
+        for doc in self.metadata['documents']:
+            filename = doc.get('filename')
+            if filename is None:
+                continue
+                
+            document_path = self.path / filename
+            yield Document(doc['type'], document_path)

datamule-1.0.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: datamule
+Version: 1.0.0
+Summary: Making it easier to use SEC filings.
+Home-page: https://github.com/john-friedman/datamule-python
+Author: John Friedman
+Requires-Dist: aiohttp
+Requires-Dist: aiolimiter
+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
+Requires-Dist: zstandard
+Requires-Dist: doc2dict
+Requires-Dist: secsgml
+Provides-Extra: all
+Requires-Dist: openai; extra == "all"
+Requires-Dist: flask; extra == "all"
+Provides-Extra: mulebot
+Requires-Dist: openai; extra == "mulebot"
+Provides-Extra: mulebot_server
+Requires-Dist: flask; extra == "mulebot-server"
+

datamule-1.0.0.dist-info/RECORD

@@ -0,0 +1,40 @@
+datamule/__init__.py,sha256=IDVK3i5i5DxLlQJ_71aYkloGNi528JOUx8hU6bDzLXM,1255
+datamule/book.py,sha256=hzp5Ae_PfTg3c_h_LdRQOc9fU6OifapKtV0bU-SyIOw,775
+datamule/config.py,sha256=Y--CVv7JcgrjJkMOSLrvm2S8B9ost6RMSkGviP-MKtg,883
+datamule/document.py,sha256=P1UeF-GLta08T7Ur77IFOp7vJBIYcQPbz3gfuWJ3fi0,10851
+datamule/helper.py,sha256=tr3AQWus9dHNZFKpLSglWjcb8zmm5qDXjOWACMhvMxQ,4594
+datamule/monitor.py,sha256=AfhGqC_GFTYWemRKgYE85V7rIGMN_pbcpxW6kORQtpw,9273
+datamule/packageupdater.py,sha256=vEGqlTj6FudIeVHBVJltPh2eBDEqMG9HYmnyrRVKeSU,9595
+datamule/portfolio.py,sha256=U_QRNk_CbMmi3nJ0VBIwc9SVEGq6kA8LCZHBj9nOGXs,4032
+datamule/submission.py,sha256=uioIYJbsoe-87nRPyzlo-LZ8Hp7HG7A4KPGSnw86PKY,2790
+datamule/data/company_former_names.csv,sha256=HE9cAv-_QKFX6jT-_-D0rHmaDyQuAzL4MJwank5O1U8,706380
+datamule/data/company_metadata.csv,sha256=yPovrCVjYwLWTU_hBUFJymp8iNO0NBYuq_QwOkRLoN8,3068599
+datamule/data/company_tickers.csv,sha256=GW6lOP54RiGJCx-d9N5jEBy7tGVgU3zI-5xHJXrZfSI,400363
+datamule/data/sec-glossary.csv,sha256=-cN7GjiadLw5C1sv4zSeCnfeZZDYeSgJl-0ydarMAo0,251209
+datamule/data/xbrl_descriptions.csv,sha256=SQ9wUURNqG424rnTiZtopsxV2q-PvU4NMj52LqgDsvg,2621524
+datamule/downloader/downloader.py,sha256=vnMsw0oWqRa84scu6ZcywxbJxsIn38vLV0tybakx3jQ,15217
+datamule/downloader/premiumdownloader.py,sha256=YhGFwkYqjLkdc5ex2YKM-L7nBAPm5MMCdTwVVP0JO78,14314
+datamule/mapping_dicts/txt_mapping_dicts.py,sha256=Eh6qYhseuKjjnxGh0A5blHr7mbq9CigFn6Zv9xcG2zU,5783
+datamule/mapping_dicts/xml_mapping_dicts.py,sha256=Z22yDVwKYonUfM5foQP00dVDE8EHhhMKp0CLqVKV5OI,438
+datamule/mulebot/__init__.py,sha256=YvZXV6xQ0iP-oGD8rloufjdwJL6D46P3NNr0CY9PQCA,29
+datamule/mulebot/helper.py,sha256=olztOwltfELZ-IERM2bRNLBavD04kfB6ueWTisJAleA,1080
+datamule/mulebot/mulebot.py,sha256=XbtgvXBSFu9OaaLW_k1KDgHVTNQGV8_0ZwNMFad-pPU,5837
+datamule/mulebot/search.py,sha256=mwvbB6Fex5dEQkfxkCL53ne5pXdVno-5KlZ5vZyGnJQ,2073
+datamule/mulebot/tools.py,sha256=ctnGc2HItR-Roi-QXkc7GEaAOEYQiFRtfmdmIxNxYXk,2940
+datamule/mulebot/mulebot_server/__init__.py,sha256=x1QhXys7BWxi2g9_ZHUYA6S6rL3VL2718x4rYtGaaIg,33
+datamule/mulebot/mulebot_server/server.py,sha256=M7kU4aZUoi8X8DUKZNckLewBiI637Krbeap31qD2jt8,3547
+datamule/mulebot/mulebot_server/static/css/minimalist.css,sha256=Tz1tz8oF_esbfCvLTJBmTfb-5MIiqjfhU_4A4nto1mo,2974
+datamule/mulebot/mulebot_server/static/scripts/artifacts.js,sha256=WUAoI3LtEBEt3x-Ri0gwd6YT0JtGNwDZ_b8tuhWWSsg,2258
+datamule/mulebot/mulebot_server/static/scripts/chat.js,sha256=q8vV_KtzuNCXCfXqavM1HROIkYHItOAmaR8P1OjSqa0,3108
+datamule/mulebot/mulebot_server/static/scripts/filingArtifacts.js,sha256=wxeIM2RzF6Zh_9ivnYuNyTzIgIcEz0-zX8gTCvyACJo,2034
+datamule/mulebot/mulebot_server/static/scripts/listArtifacts.js,sha256=DZFLe-45mmzWvJPO1be5Ivfqx0BInrXfduQ1IhbHWzk,429
+datamule/mulebot/mulebot_server/static/scripts/main.js,sha256=NEIVih1WJeQ-qo5k8hnmgFHd7N839Mr6hJur856oXVQ,1882
+datamule/mulebot/mulebot_server/static/scripts/prefilledPrompt.js,sha256=mGhAXQnjnSxYqVqg1mE5g_ev0-aDhh849xunQtRchnY,1093
+datamule/mulebot/mulebot_server/static/scripts/suggestions.js,sha256=TCyz8OYuXeIG9qNRgwU2fhz18YNXpy4Bl9mk66lXefo,1795
+datamule/mulebot/mulebot_server/static/scripts/tableArtifacts.js,sha256=UtkUpLvELNI4Ibpb7VstgVA9Tk-8jbkxXhmXsgufFa4,4437
+datamule/mulebot/mulebot_server/static/scripts/utils.js,sha256=oGPMtyT9dvuqHqrfZj33t4vLZiF8UJrMXB1hpPXRNu4,1255
+datamule/mulebot/mulebot_server/templates/chat-minimalist.html,sha256=MsTbgpnLD0JCQiKKP3XeeNJRNsRqKsRa1j_XXW7nBKw,6975
+datamule-1.0.0.dist-info/METADATA,sha256=EMOJtZUCrYTNu7YOrhfZmzapdumfM0TXsnRhDBs0x6A,732
+datamule-1.0.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+datamule-1.0.0.dist-info/top_level.txt,sha256=iOfgmtSMFVyr7JGl_bYSTDry79JbmsG4p8zKq89ktKk,9
+datamule-1.0.0.dist-info/RECORD,,

{datamule-0.381.dist-info → datamule-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py3-none-any