datamule 1.1.8__py3-none-any.whl → 1.2.0__py3-none-any.whl

datamule/document.py

@@ -129,85 +129,123 @@ class Document:
             json.dump(self.data, f, indent=2)
 
     def to_tabular(self, accession_number=None):
+        """
+        Convert the document to a tabular format suitable for CSV output.
+        
+        Args:
+            accession_number: Optional accession number to include in the output
+            
+        Returns:
+            list: List of dictionaries, each representing a row in the tabular output
+        """
         self.parse()
-
-        if self.type == "INFORMATION TABLE":
-            info_table = self.data['informationTable']['infoTable']
-            if isinstance(info_table, dict):
-                info_table = [info_table]
-
-            flattened = self._flatten_dict(info_table)
-
-            # Original field names
-            original_columns = [
-                "nameOfIssuer", "titleOfClass", "cusip", "value", 
-                "shrsOrPrnAmt_sshPrnamt", "shrsOrPrnAmt_sshPrnamtType", 
-                "investmentDiscretion", "votingAuthority_Sole", 
-                "votingAuthority_Shared", "votingAuthority_None", 
-                "reportingOwnerCIK", "putCall", "otherManager", 'figi'
-            ]
-                
-            # Define mapping from original to camelCase field names
-            field_mapping = {
-                "shrsOrPrnAmt_sshPrnamt": "sshPrnamt",
-                "shrsOrPrnAmt_sshPrnamtType": "sshPrnamtType",
-                "votingAuthority_Sole": "votingAuthoritySole",
-                "votingAuthority_Shared": "votingAuthorityShared",
-                "votingAuthority_None": "votingAuthorityNone"
-            }
+        
+        # Common function to normalize and process dictionaries
+        def process_records(records, mapping_dict, is_derivative=None):
+            """
+            Process records into a standardized tabular format
+            
+            Args:
+                records: List or single dictionary of records to process
+                mapping_dict: Dictionary mapping source keys to target keys
+                is_derivative: Boolean flag for derivative securities (or None if not applicable)
                 
-            # Create the new expected columns list with mapped field names
-            expected_columns = []
-            for column in original_columns:
-                if column in field_mapping:
-                    expected_columns.append(field_mapping[column])
-                else:
-                    expected_columns.append(column)
+            Returns:
+                list: Processed records in tabular format
+            """
+            # Convert single dict to list for uniform processing
+            if isinstance(records, dict):
+                records = [records]
                 
-            # Process each item in the flattened data
+            # Flatten nested dictionaries
+            flattened = self._flatten_dict(records)
+            
+            # Process each record
+            result = []
             for item in flattened:
-                # Remove newlines from items
+                # Normalize whitespace in all string values
                 for key in item:
                     if isinstance(item[key], str):
                         item[key] = re.sub(r'\s+', ' ', item[key])
+                        
+                # Map keys according to the mapping dictionary
+                mapped_item = {}
+                for old_key, value in item.items():
+                    target_key = mapping_dict.get(old_key, old_key)
+                    mapped_item[target_key] = value
                     
-                new_item = {}
-                for key, value in item.items():
-                    # Apply the mapping if the key is in our mapping dictionary
-                    if key in field_mapping:
-                        new_item[field_mapping[key]] = value
-                    else:
-                        new_item[key] = value
-                    
-                # Update the original item with the new keys
-                item.clear()
-                item.update(new_item)
+                # Set derivative flags if applicable
+                if is_derivative is not None:
+                    mapped_item["isDerivative"] = 1 if is_derivative else 0
+                    mapped_item["isNonDerivative"] = 0 if is_derivative else 1
                     
                 # Ensure all expected columns exist
-                for column in expected_columns:
-                    if column not in item:
-                        item[column] = None
-
-                item['accession'] = accession_number
-            
-            # Add this block to reorder the items to match the expected order
-            ordered_columns = ["nameOfIssuer", "titleOfClass", "cusip", "value", "sshPrnamt", "sshPrnamtType",
-                            "investmentDiscretion", "votingAuthoritySole", "votingAuthorityShared", "votingAuthorityNone",
-                            "reportingOwnerCIK", "putCall", "otherManager", "figi"]
-            if accession_number is not None:
-                ordered_columns.append("accession")
+                output_columns = list(dict.fromkeys(mapping_dict.values()))
+                ordered_item = {column: mapped_item.get(column, None) for column in output_columns}
                 
-            ordered_data = []
-            for item in flattened:
-                ordered_item = {column: item.get(column, None) for column in ordered_columns}
-                ordered_data.append(ordered_item)
+                # Add accession number if provided
+                if accession_number is not None:
+                    ordered_item['accession'] = accession_number
+                    
+                result.append(ordered_item)
                 
-            return ordered_data
+            return result
         
+        # Handle different document types
+        if self.type == "INFORMATION TABLE":
+            # Information Table mapping dictionary
+            info_table_mapping = {
+                "nameOfIssuer": "nameOfIssuer", 
+                "titleOfClass": "titleOfClass", 
+                "cusip": "cusip", 
+                "value": "value", 
+                "shrsOrPrnAmt_sshPrnamt": "sshPrnamt", 
+                "shrsOrPrnAmt_sshPrnamtType": "sshPrnamtType", 
+                "investmentDiscretion": "investmentDiscretion", 
+                "votingAuthority_Sole": "votingAuthoritySole", 
+                "votingAuthority_Shared": "votingAuthorityShared", 
+                "votingAuthority_None": "votingAuthorityNone", 
+                "reportingOwnerCIK": "reportingOwnerCIK", 
+                "putCall": "putCall", 
+                "otherManager": "otherManager", 
+                "figi": "figi"
+            }
+            
+            # Process the information table
+            info_table = self.data['informationTable']['infoTable']
+            return process_records(info_table, info_table_mapping)
+            
+        elif self.type == "PROXY VOTING RECORD":
+            # Proxy voting record mapping dictionary
+            proxy_mapping = {
+                'meetingDate': 'meetingDate',
+                'isin': 'isin',  
+                'cusip': 'cusip',
+                'issuerName': 'issuerName',
+                'voteDescription': 'voteDescription',
+                'sharesOnLoan': 'sharesOnLoan',
+                'vote_voteRecord_sharesVoted': 'sharesVoted',
+                'voteCategories_voteCategory_categoryType': 'voteCategory', 
+                'vote_voteRecord': 'voteRecord',
+                'sharesVoted': 'sharesVoted', 
+                'voteSource': 'voteSource', 
+                'vote_voteRecord_howVoted': 'howVoted',
+                'figi': 'figi', 
+                'vote_voteRecord_managementRecommendation': 'managementRecommendation'
+            }
+            
+            # Process proxy voting records if they exist
+            all_results = []
+            if 'proxyVoteTable' in self.data and 'proxyTable' in self.data['proxyVoteTable'] and self.data['proxyVoteTable']['proxyTable'] is not None:
+                proxy_records = self.data['proxyVoteTable']['proxyTable']
+                proxy_results = process_records(proxy_records, proxy_mapping)
+                all_results.extend(proxy_results)
+                
+            return all_results
+            
         elif self.type in ["3", "4", "5"]:
-            # Master mapping dictionary - includes all possible fields
-            # The order of this dictionary will determine the output column order
-            master_mapping_dict = {
+            # Forms 3, 4, 5 mapping dictionary
+            form_345_mapping = {
                 # Flag fields (will be set programmatically)
                 "isDerivative": "isDerivative",
                 "isNonDerivative": "isNonDerivative",
@@ -270,45 +308,6 @@ class Document:
                 "underlyingSecurity_underlyingSecurityValue_footnote": "underlyingSecurityValueFootnote"
             }
             
-            # Get the unique target column names in order from the mapping dictionary
-            output_columns = []
-            for _, target_key in master_mapping_dict.items():
-                if target_key not in output_columns:
-                    output_columns.append(target_key)
-            
-            # Process function that handles any table type
-            def process_table(table_data, is_derivative):
-                if isinstance(table_data, dict):
-                    table_data = [table_data]
-                
-                flattened = self._flatten_dict(table_data)
-                
-                # Apply mapping to the flattened data and ensure all expected columns are present
-                mapped_data = []
-                for item in flattened:
-                    mapped_item = {}
-                    # First, apply the mapping
-                    for old_key, value in item.items():
-                        target_key = master_mapping_dict.get(old_key, old_key)
-                        mapped_item[target_key] = value
-                    
-                    # Set the derivative/non-derivative flags
-                    mapped_item["isDerivative"] = 1 if is_derivative else 0
-                    mapped_item["isNonDerivative"] = 0 if is_derivative else 1
-                    
-                    # Create a new ordered dictionary with all columns
-                    ordered_item = {}
-                    for column in output_columns:
-                        ordered_item[column] = mapped_item.get(column, None)
-                    
-                    # Add accession_number if available
-                    if accession_number is not None:
-                        ordered_item['accession_number'] = accession_number
-                    
-                    mapped_data.append(ordered_item)
-                
-                return mapped_data
-            
             # Results container
             all_results = []
             
@@ -316,39 +315,33 @@ class Document:
             if 'nonDerivativeTable' in self.data['ownershipDocument'] and self.data['ownershipDocument']['nonDerivativeTable'] is not None:
                 if 'nonDerivativeTransaction' in self.data['ownershipDocument']['nonDerivativeTable']:
                     non_deriv_trans = self.data['ownershipDocument']['nonDerivativeTable']['nonDerivativeTransaction']
-                    non_deriv_results = process_table(non_deriv_trans, is_derivative=False)
+                    non_deriv_results = process_records(non_deriv_trans, form_345_mapping, is_derivative=False)
                     all_results.extend(non_deriv_results)
                 
                 # Process non-derivative holdings (for Form 3)
                 if 'nonDerivativeHolding' in self.data['ownershipDocument']['nonDerivativeTable']:
                     non_deriv_hold = self.data['ownershipDocument']['nonDerivativeTable']['nonDerivativeHolding']
-                    non_deriv_hold_results = process_table(non_deriv_hold, is_derivative=False)
+                    non_deriv_hold_results = process_records(non_deriv_hold, form_345_mapping, is_derivative=False)
                     all_results.extend(non_deriv_hold_results)
             
             # Process derivative transactions if they exist
             if 'derivativeTable' in self.data['ownershipDocument'] and self.data['ownershipDocument']['derivativeTable'] is not None:
                 if 'derivativeTransaction' in self.data['ownershipDocument']['derivativeTable']:
                     deriv_trans = self.data['ownershipDocument']['derivativeTable']['derivativeTransaction']
-                    deriv_results = process_table(deriv_trans, is_derivative=True)
+                    deriv_results = process_records(deriv_trans, form_345_mapping, is_derivative=True)
                     all_results.extend(deriv_results)
                 
                 # Process derivative holdings (for Form 3)
                 if 'derivativeHolding' in self.data['ownershipDocument']['derivativeTable']:
                     deriv_hold = self.data['ownershipDocument']['derivativeTable']['derivativeHolding']
-                    deriv_hold_results = process_table(deriv_hold, is_derivative=True)
+                    deriv_hold_results = process_records(deriv_hold, form_345_mapping, is_derivative=True)
                     all_results.extend(deriv_hold_results)
-
-            # check if any rows not in the mapping dict, raise error if so
-            for item in all_results:
-                for key in item.keys():
-                    if key not in master_mapping_dict.values() and key != 'accession_number':
-                        raise ValueError(f"Key '{key}' not found in mapping dictionary")
-
             
             return all_results
-        else:
-            raise ValueError("sorry, rejigging conversion to tabular format")
         
+        else:
+            raise ValueError(f"Document type '{self.type}' is not supported for tabular conversion")
+    
     def write_csv(self, output_filename, accession_number=None):
             
         data = self.to_tabular(accession_number)

datamule/seclibrary/bq.py

@@ -3,9 +3,6 @@ import requests
 import json
 
 def get_information_table(
-    # Required parameters
-    table_type="INFORMATION_TABLE",
-    
     # Optional filtering parameters
     columns=None,
     name_of_issuer=None,
@@ -37,8 +34,6 @@ def get_information_table(
     
     Parameters:
     -----------
-    table_type : str
-        The table to query (default is "INFORMATION_TABLE")
     columns : List[str], optional
         Specific columns to return. If None, all columns are returned.
     
@@ -76,7 +71,7 @@ def get_information_table(
         raise ValueError("No API key found. Please set DATAMULE_API_KEY environment variable or provide api_key parameter")
     
     # 2. Build query parameters
-    params = {'table_type': table_type}
+    params = {'table_type': 'INFORMATION_TABLE'}
     
     # Add columns parameter if provided
     if columns:
@@ -138,7 +133,198 @@ def get_information_table(
                 # Exact match
                 params[api_param_name] = value
     
-    # 3. Make the API request
+    # Call common function to make API request
+    return _make_api_request(params, api_key, print_cost, verbose)
+
+def get_345(
+    # Optional filtering parameters
+    columns=None,
+    is_derivative=None,
+    is_non_derivative=None,
+    security_title=None,
+    transaction_date=None,
+    document_type=None,
+    transaction_code=None,
+    equity_swap_involved=None,
+    transaction_timeliness=None,
+    transaction_shares=None,
+    transaction_price_per_share=None,
+    shares_owned_following_transaction=None,
+    ownership_type=None,
+    deemed_execution_date=None,
+    conversion_or_exercise_price=None,
+    exercise_date=None,
+    expiration_date=None,
+    underlying_security_title=None,
+    underlying_security_shares=None,
+    underlying_security_value=None,
+    accession=None,
+    reporting_owner_cik=None,
+    issuer_cik=None,
+    filing_date=None,
+    
+    # API key handling
+    api_key=None,
+    
+    # Additional options
+    print_cost=True,
+    verbose=False
+):
+    """
+    Query the SEC BigQuery API for Form 345 insider transaction data.
+    
+    Parameters:
+    -----------
+    columns : List[str], optional
+        Specific columns to return. If None, all columns are returned.
+    
+    # Filter parameters
+    is_derivative, security_title, etc. : Various filters that can be:
+        - str/bool: Exact match
+        - List[str]: Match any in list
+        - tuple: (min, max) range for numeric/date fields
+        
+    reporting_owner_cik : str or List[str]
+        CIK(s) of the reporting insider(s). This is matched against an array in BigQuery.
+        Any match within the array will return the record.
+        
+    issuer_cik : str or List[str]
+        CIK(s) of the company/companies
+    
+    api_key : str, optional
+        SEC BigQuery API key. If None, looks for DATAMULE_API_KEY env variable.
+    print_cost : bool
+        Whether to print the query cost information
+    verbose : bool
+        Whether to print additional information about the query
+        
+    Returns:
+    --------
+    List[Dict]
+        A list of dictionaries containing the query results
+        
+    Raises:
+    -------
+    ValueError
+        If API key is missing or invalid
+    Exception
+        For API errors or other issues
+    """
+    
+    # 1. Handle API key
+    if api_key is None:
+        api_key = os.getenv('DATAMULE_API_KEY')
+    
+    if not api_key:
+        raise ValueError("No API key found. Please set DATAMULE_API_KEY environment variable or provide api_key parameter")
+    
+    # 2. Build query parameters
+    params = {'table_type': 'FORM_345_TABLE'}
+    
+    # Add columns parameter if provided
+    if columns:
+        if isinstance(columns, list):
+            params['columns'] = ','.join(columns)
+        else:
+            params['columns'] = columns
+    
+    # Map Python parameter names to API parameter names
+    param_mapping = {
+        'is_derivative': 'isDerivative',
+        'is_non_derivative': 'isNonDerivative',
+        'security_title': 'securityTitle',
+        'transaction_date': 'transactionDate',
+        'document_type': 'documentType',
+        'transaction_code': 'transactionCode',
+        'equity_swap_involved': 'equitySwapInvolved',
+        'transaction_timeliness': 'transactionTimeliness',
+        'transaction_shares': 'transactionShares',
+        'transaction_price_per_share': 'transactionPricePerShare',
+        'shares_owned_following_transaction': 'sharesOwnedFollowingTransaction',
+        'ownership_type': 'ownershipType',
+        'deemed_execution_date': 'deemedExecutionDate',
+        'conversion_or_exercise_price': 'conversionOrExercisePrice',
+        'exercise_date': 'exerciseDate',
+        'expiration_date': 'expirationDate',
+        'underlying_security_title': 'underlyingSecurityTitle',
+        'underlying_security_shares': 'underlyingSecurityShares',
+        'underlying_security_value': 'underlyingSecurityValue',
+        'accession': 'accession',
+        'reporting_owner_cik': 'reportingOwnerCIK',
+        'issuer_cik': 'issuerCIK',
+        'filing_date': 'filingDate'
+    }
+    
+    # Process all possible filter parameters
+    date_params = ['transaction_date', 'filing_date', 'deemed_execution_date', 'exercise_date', 'expiration_date']
+    boolean_params = ['is_derivative', 'is_non_derivative']
+    
+    for param_name, api_param_name in param_mapping.items():
+        value = locals()[param_name]
+        if value is not None:
+            # Handle different filter types
+            if isinstance(value, list):
+                # List filter
+                params[api_param_name] = f"[{','.join(str(v) for v in value)}]"
+            elif isinstance(value, tuple):
+                # Range filter
+                if len(value) == 2:
+                    min_val, max_val = value
+                    # Handle date range specially
+                    if param_name in date_params:
+                        # Dates need to be in quotes within the parentheses
+                        if min_val is None:
+                            min_val = ''
+                        else:
+                            min_val = f"'{min_val}'"
+                        
+                        if max_val is None:
+                            max_val = ''
+                        else:
+                            max_val = f"'{max_val}'"
+                    
+                    range_str = f"({min_val},{max_val})"
+                    params[api_param_name] = range_str
+                else:
+                    raise ValueError(f"Range filter for {param_name} must be a tuple of (min, max)")
+            elif param_name in boolean_params:
+                # Boolean values
+                params[api_param_name] = str(value).lower()
+            else:
+                # Exact match
+                params[api_param_name] = value
+    
+    # Call common function to make API request
+    return _make_api_request(params, api_key, print_cost, verbose)
+
+def _make_api_request(params, api_key, print_cost=True, verbose=False):
+    """
+    Common function to make API requests to the SEC BigQuery API.
+    
+    Parameters:
+    -----------
+    params : dict
+        Query parameters
+    api_key : str
+        API key for authentication
+    print_cost : bool
+        Whether to print cost information
+    verbose : bool
+        Whether to print debugging information
+        
+    Returns:
+    --------
+    List[Dict]
+        Data returned from the API
+        
+    Raises:
+    -------
+    ValueError
+        If API key is invalid
+    Exception
+        For other API errors
+    """
+    # Make the API request
     BASE_URL = "https://sec-bq.jgfriedman99.workers.dev/"
     
     headers = {
@@ -166,7 +352,15 @@ def get_information_table(
         # Extract metadata for cost reporting
         metadata = result.get('metadata', {})
         
-        # 5. Print cost information if requested
+        # Process the data to handle array fields
+        data = result.get('data', [])
+        for row in data:
+            # Check if reportingOwnerCIK is an array that needs processing
+            if 'reportingOwnerCIK' in row and isinstance(row['reportingOwnerCIK'], list):
+                # Transform from [{'v': 'value1'}, {'v': 'value2'}] to comma-separated string
+                row['reportingOwnerCIK'] = ','.join([item['v'] for item in row['reportingOwnerCIK'] if 'v' in item])
+        
+        # Print cost information if requested
         if print_cost and 'billing' in metadata:
             billing = metadata['billing']
             query_info = metadata.get('query_info', {})
@@ -181,11 +375,154 @@ def get_information_table(
             print(f"Cache Hit: {query_info.get('cache_hit', False)}")
             print("==============================\n")
         
-        # 6. Return data
-        return result.get('data', [])
+        # Return data
+        return data
         
     except requests.exceptions.RequestException as e:
-        if response.status_code == 401:
+        if hasattr(e, 'response') and e.response is not None and e.response.status_code == 401:
             raise ValueError("Authentication failed: Invalid API key")
         else:
-            raise Exception(f"Request failed: {str(e)}")
+            raise Exception(f"Request failed: {str(e)}")
+        
+def get_proxy_voting_record(
+    # Optional filtering parameters
+    columns=None,
+    meeting_date=None,
+    isin=None,
+    cusip=None,
+    issuer_name=None,
+    vote_description=None,
+    shares_on_loan=None,
+    shares_voted=None,
+    vote_category=None,
+    vote_record=None,
+    vote_source=None,
+    how_voted=None,
+    figi=None,
+    management_recommendation=None,
+    accession=None,
+    reporting_owner_cik=None,
+    filing_date=None,
+    
+    # API key handling
+    api_key=None,
+    
+    # Additional options
+    print_cost=True,
+    verbose=False
+):
+    """
+    Query the SEC BigQuery API for NPX proxy voting record data.
+    
+    Parameters:
+    -----------
+    columns : List[str], optional
+        Specific columns to return. If None, all columns are returned.
+    
+    # Filter parameters
+    meeting_date, isin, cusip, etc. : Various filters that can be:
+        - str: Exact match
+        - List[str]: Match any in list
+        - tuple: (min, max) range for numeric/date fields
+    
+    shares_on_loan, shares_voted : int/float or tuple
+        Numeric values or (min, max) range
+        
+    filing_date : str or tuple
+        Date string in 'YYYY-MM-DD' format or (start_date, end_date) tuple
+    
+    api_key : str, optional
+        SEC BigQuery API key. If None, looks for DATAMULE_API_KEY env variable.
+    print_cost : bool
+        Whether to print the query cost information
+    verbose : bool
+        Whether to print additional information about the query
+        
+    Returns:
+    --------
+    List[Dict]
+        A list of dictionaries containing the query results
+        
+    Raises:
+    -------
+    ValueError
+        If API key is missing or invalid
+    Exception
+        For API errors or other issues
+    """
+    
+    # 1. Handle API key
+    if api_key is None:
+        api_key = os.getenv('DATAMULE_API_KEY')
+    
+    if not api_key:
+        raise ValueError("No API key found. Please set DATAMULE_API_KEY environment variable or provide api_key parameter")
+    
+    # 2. Build query parameters
+    params = {'table_type': 'NPX_VOTING_TABLE'}
+    
+    # Add columns parameter if provided
+    if columns:
+        if isinstance(columns, list):
+            params['columns'] = ','.join(columns)
+        else:
+            params['columns'] = columns
+    
+    # Map Python parameter names to API parameter names
+    param_mapping = {
+        'meeting_date': 'meetingDate',
+        'isin': 'isin',
+        'cusip': 'cusip',
+        'issuer_name': 'issuerName',
+        'vote_description': 'voteDescription',
+        'shares_on_loan': 'sharesOnLoan',
+        'shares_voted': 'sharesVoted',
+        'vote_category': 'voteCategory',
+        'vote_record': 'voteRecord',
+        'vote_source': 'voteSource',
+        'how_voted': 'howVoted',
+        'figi': 'figi',
+        'management_recommendation': 'managementRecommendation',
+        'accession': 'accession',
+        'reporting_owner_cik': 'reportingOwnerCIK',
+        'filing_date': 'filingDate'
+    }
+    
+    # Process all possible filter parameters
+    date_params = ['meeting_date', 'filing_date']
+    numeric_params = ['shares_on_loan', 'shares_voted']
+    
+    for param_name, api_param_name in param_mapping.items():
+        value = locals()[param_name]
+        if value is not None:
+            # Handle different filter types
+            if isinstance(value, list):
+                # List filter
+                params[api_param_name] = f"[{','.join(str(v) for v in value)}]"
+            elif isinstance(value, tuple):
+                # Range filter
+                if len(value) == 2:
+                    min_val, max_val = value
+                    # Handle date range specially
+                    if param_name in date_params:
+                        # Dates need to be in quotes within the parentheses
+                        if min_val is None:
+                            min_val = ''
+                        else:
+                            min_val = f"'{min_val}'"
+                        
+                        if max_val is None:
+                            max_val = ''
+                        else:
+                            max_val = f"'{max_val}'"
+                    
+                    range_str = f"({min_val},{max_val})"
+                    params[api_param_name] = range_str
+                else:
+                    raise ValueError(f"Range filter for {param_name} must be a tuple of (min, max)")
+            else:
+                # Exact match
+                params[api_param_name] = value
+    
+    # Call common function to make API request
+    return _make_api_request(params, api_key, print_cost, verbose)

datamule/sheet.py

@@ -3,7 +3,7 @@ import csv
 import os
 from .helper import _process_cik_and_metadata_filters, load_package_dataset
 from .sec.xbrl.downloadcompanyfacts import download_company_facts
-from .seclibrary.bq import get_information_table
+from .seclibrary.bq import get_information_table, get_345, get_proxy_voting_record
 
 class Sheet:
     def __init__(self, path):
@@ -31,9 +31,6 @@ class Sheet:
 
     def get_information_table(
         self,
-        # Required parameters
-        table_type="INFORMATION_TABLE",
-        
         # Optional filtering parameters
         columns=None,
         name_of_issuer=None,
@@ -65,8 +62,6 @@ class Sheet:
         
         Parameters:
         -----------
-        table_type : str
-            The table to query (default is "INFORMATION_TABLE")
         columns : List[str], optional
             Specific columns to return. If None, all columns are returned.
         
@@ -97,7 +92,6 @@ class Sheet:
         """
 
         return get_information_table(
-            table_type=table_type,
             columns=columns,
             name_of_issuer=name_of_issuer,
             title_of_class=title_of_class,
@@ -124,12 +118,164 @@ class Sheet:
             verbose=verbose
         )
 
+    def get_345(
+        self,
+        # Optional filtering parameters
+        columns=None,
+        is_derivative=None,
+        is_non_derivative=None,
+        security_title=None,
+        transaction_date=None,
+        document_type=None,
+        transaction_code=None,
+        equity_swap_involved=None,
+        transaction_timeliness=None,
+        transaction_shares=None,
+        transaction_price_per_share=None,
+        shares_owned_following_transaction=None,
+        ownership_type=None,
+        deemed_execution_date=None,
+        conversion_or_exercise_price=None,
+        exercise_date=None,
+        expiration_date=None,
+        underlying_security_title=None,
+        underlying_security_shares=None,
+        underlying_security_value=None,
+        accession=None,
+        reporting_owner_cik=None,
+        issuer_cik=None,
+        filing_date=None,
+        
+        # API key handling
+        api_key=None,
+        
+        # Additional options
+        print_cost=True,
+        verbose=False
+    ):
+        """
+        Query the SEC BigQuery API for Form 345 insider transaction data.
+        
+        Parameters:
+        -----------
+        columns : List[str], optional
+            Specific columns to return. If None, all columns are returned.
+        
+        # Filter parameters
+        is_derivative, security_title, etc. : Various filters that can be:
+            - str/bool: Exact match
+            - List[str]: Match any in list
+            - tuple: (min, max) range for numeric/date fields
+            
+        reporting_owner_cik : str or List[str]
+            CIK(s) of the reporting insider(s). This is matched against an array in BigQuery.
+            Any match within the array will return the record.
+            
+        issuer_cik : str or List[str]
+            CIK(s) of the company/companies
+        
+        api_key : str, optional
+            SEC BigQuery API key. If None, looks for DATAMULE_API_KEY env variable.
+        print_cost : bool
+            Whether to print the query cost information
+        verbose : bool
+            Whether to print additional information about the query
+            
+        Returns:
+        --------
+        List[Dict]
+            A list of dictionaries containing the query results
+            
+        Raises:
+        -------
+        ValueError
+            If API key is missing or invalid
+        Exception
+            For API errors or other issues
+        """
+
+        return get_345(
+            columns=columns,
+            is_derivative=is_derivative,
+            is_non_derivative=is_non_derivative,
+            security_title=security_title,
+            transaction_date=transaction_date,
+            document_type=document_type,
+            transaction_code=transaction_code,
+            equity_swap_involved=equity_swap_involved,
+            transaction_timeliness=transaction_timeliness,
+            transaction_shares=transaction_shares,
+            transaction_price_per_share=transaction_price_per_share,
+            shares_owned_following_transaction=shares_owned_following_transaction,
+            ownership_type=ownership_type,
+            deemed_execution_date=deemed_execution_date,
+            conversion_or_exercise_price=conversion_or_exercise_price,
+            exercise_date=exercise_date,
+            expiration_date=expiration_date,
+            underlying_security_title=underlying_security_title,
+            underlying_security_shares=underlying_security_shares,
+            underlying_security_value=underlying_security_value,
+            accession=accession,
+            reporting_owner_cik=reporting_owner_cik,
+            issuer_cik=issuer_cik,
+            filing_date=filing_date,
+            
+            # API key handling
+            api_key=api_key,
+            
+            # Additional options
+            print_cost=print_cost,
+            verbose=verbose
+        )
+
+    def _download_to_csv(self, data, filepath, verbose=False):
+        """
+        Helper method to download data to a CSV file.
+        
+        Parameters:
+        -----------
+        data : List[Dict]
+            The data to save
+        filepath : str or Path
+            Path where to save the CSV file. If relative, it will be relative to the Sheet's path.
+        verbose : bool
+            Whether to print additional information
+            
+        Returns:
+        --------
+        List[Dict]
+            The input data (for method chaining)
+        """
+        # If no data returned, nothing to save
+        if not data:
+            if verbose:
+                print("No data returned from API. No file was created.")
+            return data
+        
+        # Resolve filepath - if it's not absolute, make it relative to self.path
+        filepath_obj = Path(filepath)
+        if not filepath_obj.is_absolute():
+            filepath_obj = self.path / filepath_obj
+        
+        # Create directory if it doesn't exist
+        os.makedirs(filepath_obj.parent, exist_ok=True)
+        
+        # Get fieldnames from the first record
+        fieldnames = data[0].keys()
+        
+        # Write to CSV
+        with open(filepath_obj, 'w', newline='') as csvfile:
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(data)
+            
+        if verbose:
+            print(f"Saved {len(data)} records to {filepath_obj}")
+            
+        
     def download_information_table(
         self,
         filepath,
-        # Required parameters
-        table_type="INFORMATION_TABLE",
-        
         # Optional filtering parameters
         columns=None,
         name_of_issuer=None,
@@ -164,8 +310,6 @@ class Sheet:
         filepath : str
             Path where to save the CSV file. If relative, it will be relative to the Sheet's path.
         
-        table_type : str
-            The table to query (default is "INFORMATION_TABLE")
         columns : List[str], optional
             Specific columns to return. If None, all columns are returned.
         
@@ -196,7 +340,6 @@ class Sheet:
         """
         # Get the data from the API
         data = self.get_information_table(
-            table_type=table_type,
             columns=columns,
             name_of_issuer=name_of_issuer,
             title_of_class=title_of_class,
@@ -219,30 +362,311 @@ class Sheet:
             verbose=verbose
         )
         
-        # If no data returned, nothing to save
-        if not data:
-            if verbose:
-                print("No data returned from API. No file was created.")
-            return data
+        # Save to CSV using the helper method
+        return self._download_to_csv(data, filepath, verbose)
+
+    def download_345(
+        self,
+        filepath,
+        # Optional filtering parameters
+        columns=None,
+        is_derivative=None,
+        is_non_derivative=None,
+        security_title=None,
+        transaction_date=None,
+        document_type=None,
+        transaction_code=None,
+        equity_swap_involved=None,
+        transaction_timeliness=None,
+        transaction_shares=None,
+        transaction_price_per_share=None,
+        shares_owned_following_transaction=None,
+        ownership_type=None,
+        deemed_execution_date=None,
+        conversion_or_exercise_price=None,
+        exercise_date=None,
+        expiration_date=None,
+        underlying_security_title=None,
+        underlying_security_shares=None,
+        underlying_security_value=None,
+        accession=None,
+        reporting_owner_cik=None,
+        issuer_cik=None,
+        filing_date=None,
         
-        # Resolve filepath - if it's not absolute, make it relative to self.path
-        filepath_obj = Path(filepath)
-        if not filepath_obj.is_absolute():
-            filepath_obj = self.path / filepath_obj
+        # API key handling
+        api_key=None,
         
-        # Create directory if it doesn't exist
-        os.makedirs(filepath_obj.parent, exist_ok=True)
+        # Additional options
+        print_cost=True,
+        verbose=False
+    ):
+        """
+        Query the SEC BigQuery API for Form 345 insider transaction data and save to CSV.
         
-        # Get fieldnames from the first record
-        fieldnames = data[0].keys()
+        Parameters:
+        -----------
+        filepath : str
+            Path where to save the CSV file. If relative, it will be relative to the Sheet's path.
         
-        # Write to CSV
-        with open(filepath_obj, 'w', newline='') as csvfile:
-            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
-            writer.writeheader()
-            writer.writerows(data)
+        columns : List[str], optional
+            Specific columns to return. If None, all columns are returned.
+        
+        # Filter parameters
+        is_derivative, security_title, etc. : Various filters that can be:
+            - str/bool: Exact match
+            - List[str]: Match any in list
+            - tuple: (min, max) range for numeric/date fields
             
-        if verbose:
-            print(f"Saved {len(data)} records to {filepath_obj}")
+        reporting_owner_cik : str or List[str]
+            CIK(s) of the reporting insider(s). This is matched against an array in BigQuery.
+            Any match within the array will return the record.
+            
+        issuer_cik : str or List[str]
+            CIK(s) of the company/companies
+        
+        api_key : str, optional
+            SEC BigQuery API key. If None, looks for DATAMULE_API_KEY env variable.
+        print_cost : bool
+            Whether to print the query cost information
+        verbose : bool
+            Whether to print additional information about the query
             
-        return data
+        Returns:
+        --------
+        List[Dict]
+            A list of dictionaries containing the query results
+            
+        Raises:
+        -------
+        ValueError
+            If API key is missing or invalid
+        Exception
+            For API errors or other issues
+        """
+        # Get the data from the API
+        data = self.get_345(
+            columns=columns,
+            is_derivative=is_derivative,
+            is_non_derivative=is_non_derivative,
+            security_title=security_title,
+            transaction_date=transaction_date,
+            document_type=document_type,
+            transaction_code=transaction_code,
+            equity_swap_involved=equity_swap_involved,
+            transaction_timeliness=transaction_timeliness,
+            transaction_shares=transaction_shares,
+            transaction_price_per_share=transaction_price_per_share,
+            shares_owned_following_transaction=shares_owned_following_transaction,
+            ownership_type=ownership_type,
+            deemed_execution_date=deemed_execution_date,
+            conversion_or_exercise_price=conversion_or_exercise_price,
+            exercise_date=exercise_date,
+            expiration_date=expiration_date,
+            underlying_security_title=underlying_security_title,
+            underlying_security_shares=underlying_security_shares,
+            underlying_security_value=underlying_security_value,
+            accession=accession,
+            reporting_owner_cik=reporting_owner_cik,
+            issuer_cik=issuer_cik,
+            filing_date=filing_date,
+            api_key=api_key,
+            print_cost=print_cost,
+            verbose=verbose
+        )
+        
+        # Save to CSV using the helper method
+        return self._download_to_csv(data, filepath, verbose)
+    
+    def get_proxy_voting_record(
+        self,
+        # Optional filtering parameters
+        columns=None,
+        meeting_date=None,
+        isin=None,
+        cusip=None,
+        issuer_name=None,
+        vote_description=None,
+        shares_on_loan=None,
+        shares_voted=None,
+        vote_category=None,
+        vote_record=None,
+        vote_source=None,
+        how_voted=None,
+        figi=None,
+        management_recommendation=None,
+        accession=None,
+        reporting_owner_cik=None,
+        filing_date=None,
+        
+        # API key handling
+        api_key=None,
+        
+        # Additional options
+        print_cost=True,
+        verbose=False
+    ):
+        """
+        Query the SEC BigQuery API for NPX proxy voting record data.
+        
+        Parameters:
+        -----------
+        columns : List[str], optional
+            Specific columns to return. If None, all columns are returned.
+        
+        # Filter parameters
+        meeting_date, isin, cusip, etc. : Various filters that can be:
+            - str: Exact match
+            - List[str]: Match any in list
+            - tuple: (min, max) range for numeric/date fields
+        
+        shares_on_loan, shares_voted : int/float or tuple
+            Numeric values or (min, max) range
+            
+        filing_date : str or tuple
+            Date string in 'YYYY-MM-DD' format or (start_date, end_date) tuple
+        
+        api_key : str, optional
+            SEC BigQuery API key. If None, looks for DATAMULE_API_KEY env variable.
+        print_cost : bool
+            Whether to print the query cost information
+        verbose : bool
+            Whether to print additional information about the query
+            
+        Returns:
+        --------
+        List[Dict]
+            A list of dictionaries containing the query results
+            
+        Raises:
+        -------
+        ValueError
+            If API key is missing or invalid
+        Exception
+            For API errors or other issues
+        """
+
+        return get_proxy_voting_record(
+            columns=columns,
+            meeting_date=meeting_date,
+            isin=isin,
+            cusip=cusip,
+            issuer_name=issuer_name,
+            vote_description=vote_description,
+            shares_on_loan=shares_on_loan,
+            shares_voted=shares_voted,
+            vote_category=vote_category,
+            vote_record=vote_record,
+            vote_source=vote_source,
+            how_voted=how_voted,
+            figi=figi,
+            management_recommendation=management_recommendation,
+            accession=accession,
+            reporting_owner_cik=reporting_owner_cik,
+            filing_date=filing_date,
+            
+            # API key handling
+            api_key=api_key,
+            
+            # Additional options
+            print_cost=print_cost,
+            verbose=verbose
+        )
+
+    def download_proxy_voting_record(
+        self,
+        filepath,
+        # Optional filtering parameters
+        columns=None,
+        meeting_date=None,
+        isin=None,
+        cusip=None,
+        issuer_name=None,
+        vote_description=None,
+        shares_on_loan=None,
+        shares_voted=None,
+        vote_category=None,
+        vote_record=None,
+        vote_source=None,
+        how_voted=None,
+        figi=None,
+        management_recommendation=None,
+        accession=None,
+        reporting_owner_cik=None,
+        filing_date=None,
+        
+        # API key handling
+        api_key=None,
+        
+        # Additional options
+        print_cost=True,
+        verbose=False
+    ):
+        """
+        Query the SEC BigQuery API for NPX proxy voting record data and save to CSV.
+        
+        Parameters:
+        -----------
+        filepath : str
+            Path where to save the CSV file. If relative, it will be relative to the Sheet's path.
+        
+        columns : List[str], optional
+            Specific columns to return. If None, all columns are returned.
+        
+        # Filter parameters
+        meeting_date, isin, cusip, etc. : Various filters that can be:
+            - str: Exact match
+            - List[str]: Match any in list
+            - tuple: (min, max) range for numeric/date fields
+        
+        shares_on_loan, shares_voted : int/float or tuple
+            Numeric values or (min, max) range
+            
+        filing_date : str or tuple
+            Date string in 'YYYY-MM-DD' format or (start_date, end_date) tuple
+        
+        api_key : str, optional
+            SEC BigQuery API key. If None, looks for DATAMULE_API_KEY env variable.
+        print_cost : bool
+            Whether to print the query cost information
+        verbose : bool
+            Whether to print additional information about the query
+            
+        Returns:
+        --------
+        List[Dict]
+            A list of dictionaries containing the query results
+            
+        Raises:
+        -------
+        ValueError
+            If API key is missing or invalid
+        Exception
+            For API errors or other issues
+        """
+        # Get the data from the API
+        data = self.get_proxy_voting_record(
+            columns=columns,
+            meeting_date=meeting_date,
+            isin=isin,
+            cusip=cusip,
+            issuer_name=issuer_name,
+            vote_description=vote_description,
+            shares_on_loan=shares_on_loan,
+            shares_voted=shares_voted,
+            vote_category=vote_category,
+            vote_record=vote_record,
+            vote_source=vote_source,
+            how_voted=how_voted,
+            figi=figi,
+            management_recommendation=management_recommendation,
+            accession=accession,
+            reporting_owner_cik=reporting_owner_cik,
+            filing_date=filing_date,
+            api_key=api_key,
+            print_cost=print_cost,
+            verbose=verbose
+        )
+        
+        # Save to CSV using the helper method
+        return self._download_to_csv(data, filepath, verbose)

{datamule-1.1.8.dist-info → datamule-1.2.0.dist-info}/METADATA

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

{datamule-1.1.8.dist-info → datamule-1.2.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 datamule/__init__.py,sha256=l6YlwT5EeRxPlCtO5Jd4I8l266rSRUJyfFe97cRtSCM,991
 datamule/config.py,sha256=Y--CVv7JcgrjJkMOSLrvm2S8B9ost6RMSkGviP-MKtg,883
-datamule/document.py,sha256=qShyVKHQ1nSCNvSfrhAOMVXprOd1br1rFKLy52S9WnE,22007
+datamule/document.py,sha256=CvuyazJ1qP8Ygpv49ikMc8DyGK7N-tApTU2Ccgv57q4,21556
 datamule/helper.py,sha256=xgOVnea-lUlQ5I-U0vYUp0VeKPNZehNhqjJvegA3lYE,3342
 datamule/index.py,sha256=0txvbzPcvY1GsdxA-wGdLzAByxSeE_1VyyBp9mZEQRM,2292
 datamule/portfolio.py,sha256=yWt5gYTjV7rJsLiPUmhc6Vmr3lfvfCR5MSpLQ_6Gdp4,7104
-datamule/sheet.py,sha256=QaArtx7LpT7bwyteelJV67C-lK0RjQbGS3ka7ftdi8w,7978
+datamule/sheet.py,sha256=TvFqK9eAYuVoJ2uWdAlx5EN6vS9lke-aZf7FqtUiDBc,22304
 datamule/submission.py,sha256=LI7Zr60YbE_tU-v2N09k2dGjfztSgplKZACT3eRUkFE,4463
 datamule/mapping_dicts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datamule/mapping_dicts/txt_mapping_dicts.py,sha256=DQPrGYbAPQxomRUtt4iiMGrwuF7BHc_LeFBQuYBzU9o,6311
@@ -27,10 +27,10 @@ datamule/sec/xbrl/filter_xbrl.py,sha256=g9OT4zrNS0tiUJeBIwbCs_zMisOBkpFnMR3tV4Tr
 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/bq.py,sha256=C6kafFXWtm-MUjf70H1wTtpwv1Rxpcbk-Kfy8fkBPfo,6469
+datamule/seclibrary/bq.py,sha256=C8sb_rpXTvchprrFLcbRar4Qi0XWW25tnv1YsHSS5o4,18025
 datamule/seclibrary/downloader.py,sha256=Zb1TxsIz887tO3MJVP66siYVtNus89ti-g9oZ6VywrM,11500
 datamule/seclibrary/query.py,sha256=qGuursTERRbOGfoDcYcpo4oWkW3PCBW6x1Qf1Puiak4,7352
-datamule-1.1.8.dist-info/METADATA,sha256=8HRRMz6l928E5tuHXkPi1_Kf-8nfPSjWQnnfReSxdPM,512
-datamule-1.1.8.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-datamule-1.1.8.dist-info/top_level.txt,sha256=iOfgmtSMFVyr7JGl_bYSTDry79JbmsG4p8zKq89ktKk,9
-datamule-1.1.8.dist-info/RECORD,,
+datamule-1.2.0.dist-info/METADATA,sha256=IDVSWEibrVQWmrNKEXrD1oaucOpmP7Agr4f6bv6o3Kg,512
+datamule-1.2.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+datamule-1.2.0.dist-info/top_level.txt,sha256=iOfgmtSMFVyr7JGl_bYSTDry79JbmsG4p8zKq89ktKk,9
+datamule-1.2.0.dist-info/RECORD,,

{datamule-1.1.8.dist-info → datamule-1.2.0.dist-info}/WHEEL

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