Standardize parameter naming: replace standardize with standard=True

Fix issue #403 by removing the inconsistent 'standardize' parameter and
using only 'standard=True' throughout the stitched statements API.

Changes:
- Replace standardize parameter with standard=True in all StitchedStatements methods
- Update internal APIs (XBRLS.get_statement, StitchedFactsView.get_facts) to use standard parameter
- Update documentation examples to use standard=True consistently
- Add comprehensive regression and verification tests
- Maintain same functionality while simplifying the API

All statement methods now consistently accept:
- statements.income_statement(standard=True/False)
- statements.balance_sheet(standard=True/False)
- statements.cashflow_statement(standard=True/False)
- statements.statement_of_equity(standard=True/False)
- statements.comprehensive_income(standard=True/False)

Resolves the documentation inconsistency where docs showed standard=True
but methods only accepted standardize parameter.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: dgunning

docs/guides/extract-statements.md

@@ -398,10 +398,10 @@ print(income_with_dates)
 
 ```python
 # Use standardized labels for cross-company comparison (default)
-standardized = statements.income_statement(standardize=True)
+standardized = statements.income_statement(standard=True)
 
 # Use company-specific labels as reported in filing
-company_specific = statements.income_statement(standardize=False)
+company_specific = statements.income_statement(standard=False)
 
 print("Standardized Labels:")
 print(standardized.to_dataframe()['label'].head(10))

edgar/xbrl/statements.py

@@ -925,7 +925,7 @@ class StitchedStatement:
     financial statement from multiple filings.
     """
 
-    def __init__(self, xbrls, statement_type: str, max_periods: int = 8, standardize: bool = True,
+    def __init__(self, xbrls, statement_type: str, max_periods: int = 8, standard: bool = True,
                  use_optimal_periods: bool = True, include_dimensions: bool = False):
         """
         Initialize with XBRLS object and statement parameters.
@@ -934,14 +934,14 @@ def __init__(self, xbrls, statement_type: str, max_periods: int = 8, standardize
             xbrls: XBRLS object containing stitched data
             statement_type: Type of statement ('BalanceSheet', 'IncomeStatement', etc.)
             max_periods: Maximum number of periods to include
-            standardize: Whether to use standardized concept labels
+            standard: Whether to use standardized concept labels
             use_optimal_periods: Whether to use entity info to determine optimal periods
             include_dimensions: Whether to include dimensional segment data (default: False for stitching)
         """
         self.xbrls = xbrls
         self.statement_type = statement_type
         self.max_periods = max_periods
-        self.standardize = standardize
+        self.standard = standard
         self.use_optimal_periods = use_optimal_periods
         self.include_dimensions = include_dimensions
         self.show_date_range = False  # Default to not showing date ranges
@@ -972,7 +972,7 @@ def statement_data(self):
             self._statement_data = self.xbrls.get_statement(
                 self.statement_type,
                 self.max_periods,
-                self.standardize,
+                self.standard,
                 self.use_optimal_periods,
                 self.include_dimensions
             )
@@ -1041,97 +1041,97 @@ def __init__(self, xbrls):
         """
         self.xbrls = xbrls
 
-    def balance_sheet(self, max_periods: int = 8, standardize: bool = True,
+    def balance_sheet(self, max_periods: int = 8, standard: bool = True,
                       use_optimal_periods: bool = True, show_date_range: bool = False) -> Optional[StitchedStatement]:
         """
         Get a stitched balance sheet across multiple time periods.
         
         Args:
             max_periods: Maximum number of periods to include
-            standardize: Whether to use standardized concept labels
+            standard: Whether to use standardized concept labels
             use_optimal_periods: Whether to use entity info to determine optimal periods
             show_date_range: Whether to show full date ranges for duration periods
             
         Returns:
             StitchedStatement for the balance sheet
         """
-        statement = StitchedStatement(self.xbrls, 'BalanceSheet', max_periods, standardize, use_optimal_periods)
+        statement = StitchedStatement(self.xbrls, 'BalanceSheet', max_periods, standard, use_optimal_periods)
         if show_date_range:
             statement.show_date_range = show_date_range
         return statement
 
-    def income_statement(self, max_periods: int = 8, standardize: bool = True,
+    def income_statement(self, max_periods: int = 8, standard: bool = True,
                          use_optimal_periods: bool = True, show_date_range: bool = False) -> Optional[StitchedStatement]:
         """
         Get a stitched income statement across multiple time periods.
         
         Args:
             max_periods: Maximum number of periods to include
-            standardize: Whether to use standardized concept labels
+            standard: Whether to use standardized concept labels
             use_optimal_periods: Whether to use entity info to determine optimal periods
             show_date_range: Whether to show full date ranges for duration periods
             
         Returns:
             StitchedStatement for the income statement
         """
-        statement = StitchedStatement(self.xbrls, 'IncomeStatement', max_periods, standardize, use_optimal_periods)
+        statement = StitchedStatement(self.xbrls, 'IncomeStatement', max_periods, standard, use_optimal_periods)
         if show_date_range:
             statement.show_date_range = show_date_range
         return statement
 
-    def cashflow_statement(self, max_periods: int = 8, standardize: bool = True,
+    def cashflow_statement(self, max_periods: int = 8, standard: bool = True,
                            use_optimal_periods: bool = True, show_date_range: bool = False) -> Optional[StitchedStatement]:
         """
         Get a stitched cash flow statement across multiple time periods.
         
         Args:
             max_periods: Maximum number of periods to include
-            standardize: Whether to use standardized concept labels
+            standard: Whether to use standardized concept labels
             use_optimal_periods: Whether to use entity info to determine optimal periods
             show_date_range: Whether to show full date ranges for duration periods
             
         Returns:
             StitchedStatement for the cash flow statement
         """
-        statement = StitchedStatement(self.xbrls, 'CashFlowStatement', max_periods, standardize, use_optimal_periods)
+        statement = StitchedStatement(self.xbrls, 'CashFlowStatement', max_periods, standard, use_optimal_periods)
         if show_date_range:
             statement.show_date_range = show_date_range
         return statement
 
-    def statement_of_equity(self, max_periods: int = 8, standardize: bool = True,
+    def statement_of_equity(self, max_periods: int = 8, standard: bool = True,
                             use_optimal_periods: bool = True, show_date_range: bool = False) -> Optional[StitchedStatement]:
         """
         Get a stitched statement of changes in equity across multiple time periods.
         
         Args:
             max_periods: Maximum number of periods to include
-            standardize: Whether to use standardized concept labels
+            standard: Whether to use standardized concept labels
             use_optimal_periods: Whether to use entity info to determine optimal periods
             show_date_range: Whether to show full date ranges for duration periods
             
         Returns:
             StitchedStatement for the statement of equity
         """
-        statement = StitchedStatement(self.xbrls, 'StatementOfEquity', max_periods, standardize, use_optimal_periods)
+        statement = StitchedStatement(self.xbrls, 'StatementOfEquity', max_periods, standard, use_optimal_periods)
         if show_date_range:
             statement.show_date_range = show_date_range
         return statement
 
-    def comprehensive_income(self, max_periods: int = 8, standardize: bool = True,
+    def comprehensive_income(self, max_periods: int = 8, standard: bool = True,
                              use_optimal_periods: bool = True, show_date_range: bool = False) -> Optional[StitchedStatement]:
         """
         Get a stitched statement of comprehensive income across multiple time periods.
         
         Args:
             max_periods: Maximum number of periods to include
-            standardize: Whether to use standardized concept labels
+            standard: Whether to use standardized concept labels
             use_optimal_periods: Whether to use entity info to determine optimal periods
             show_date_range: Whether to show full date ranges for duration periods
             
         Returns:
             StitchedStatement for the comprehensive income statement
         """
-        statement = StitchedStatement(self.xbrls, 'ComprehensiveIncome', max_periods, standardize, use_optimal_periods)
+        statement = StitchedStatement(self.xbrls, 'ComprehensiveIncome', max_periods, standard, use_optimal_periods)
         if show_date_range:
             statement.show_date_range = show_date_range
         return statement

edgar/xbrl/stitching/query.py

@@ -54,21 +54,21 @@ def document_type(self):
 
     def get_facts(self, 
                   max_periods: int = 8, 
-                  standardize: bool = True, 
+                  standard: bool = True, 
                   statement_types: Optional[List[str]] = None) -> List[Dict[str, Any]]:
         """
         Extract facts from stitched statements.
         
         Args:
             max_periods: Maximum periods to include
-            standardize: Whether to use standardized labels
+            standard: Whether to use standardized labels
             statement_types: List of statement types to include
             
         Returns:
             List of fact dictionaries with stitched/standardized data
         """
         # Create cache key
-        cache_key = (max_periods, standardize, tuple(statement_types or []))
+        cache_key = (max_periods, standard, tuple(statement_types or []))
         if self._facts_cache and self._last_cache_key == cache_key:
             return self._facts_cache
 
@@ -85,7 +85,7 @@ def get_facts(self,
                 stitched_data = self.xbrls.get_statement(
                     statement_type=statement_type,
                     max_periods=max_periods,
-                    standardize=standardize
+                    standard=standard
                 )
 
                 # Extract facts from stitched data
@@ -276,7 +276,7 @@ def __init__(self, stitched_facts_view: StitchedFactsView, **kwargs):
 
         # Store query-specific parameters for get_facts
         self._max_periods = kwargs.get('max_periods', 8)
-        self._standardize = kwargs.get('standardize', True)
+        self._standard = kwargs.get('standard', True)
         self._statement_types = kwargs.get('statement_types', None)
 
     def __str__(self):
@@ -400,7 +400,7 @@ def execute(self) -> List[Dict[str, Any]]:
         # Get base results from stitched facts with query parameters
         results = self._stitched_facts_view.get_facts(
             max_periods=self._max_periods,
-            standardize=self._standardize,
+            standard=self._standard,
             statement_types=self._statement_types
         )
 

edgar/xbrl/stitching/xbrls.py

@@ -135,7 +135,7 @@ def query(self,
 
     def get_statement(self, statement_type: str, 
                      max_periods: int = 8, 
-                     standardize: bool = True,
+                     standard: bool = True,
                      use_optimal_periods: bool = True,
                      include_dimensions: bool = False) -> Dict[str, Any]:
         """
@@ -144,15 +144,15 @@ def get_statement(self, statement_type: str,
         Args:
             statement_type: Type of statement to stitch ('IncomeStatement', 'BalanceSheet', etc.)
             max_periods: Maximum number of periods to include
-            standardize: Whether to use standardized concept labels
+            standard: Whether to use standardized concept labels
             use_optimal_periods: Whether to use entity info to determine optimal periods
             include_dimensions: Whether to include dimensional segment data (default: False for stitching)
             
         Returns:
             Dictionary with stitched statement data
         """
         # Check cache first
-        cache_key = f"{statement_type}_{max_periods}_{standardize}_{use_optimal_periods}_{include_dimensions}"
+        cache_key = f"{statement_type}_{max_periods}_{standard}_{use_optimal_periods}_{include_dimensions}"
         if cache_key in self._statement_cache:
             return self._statement_cache[cache_key]
 
@@ -162,7 +162,7 @@ def get_statement(self, statement_type: str,
             statement_type=statement_type,
             period_type=StatementStitcher.PeriodType.ALL_PERIODS,
             max_periods=max_periods,
-            standard=standardize,
+            standard=standard,
             use_optimal_periods=use_optimal_periods,
             include_dimensions=include_dimensions
         )

tests/issues/regression/test_issue_403_standard_parameter_regression.py

@@ -0,0 +1,141 @@
+"""
+Regression test for GitHub issue #403: Support standard=True in stitched statements
+
+This test ensures that the 'standard' parameter support in stitched statements 
+doesn't regress in future changes.
+
+Issue URL: https://github.com/dgunning/edgartools/issues/403
+"""
+
+import pytest
+from unittest.mock import MagicMock
+from edgar.xbrl.statements import StitchedStatements
+from edgar.xbrl.stitching.xbrls import XBRLS
+
+
+class TestIssue403Regression:
+    """Regression test for standard parameter in stitched statements."""
+    
+    def setup_method(self):
+        """Set up mock objects for testing."""
+        self.mock_xbrls = MagicMock(spec=XBRLS)
+        self.statements = StitchedStatements(self.mock_xbrls)
+        
+    def test_all_statement_methods_accept_standard_parameter(self):
+        """
+        Regression test: All statement methods must accept 'standard' parameter.
+        
+        This prevents accidental removal of the standard parameter in future changes.
+        """
+        # List of all statement methods that should accept 'standard' parameter
+        statement_methods = [
+            'income_statement',
+            'balance_sheet', 
+            'cashflow_statement',
+            'statement_of_equity',
+            'comprehensive_income'
+        ]
+        
+        # Test that each method accepts standard=True without raising TypeError
+        for method_name in statement_methods:
+            method = getattr(self.statements, method_name)
+            
+            # This should not raise TypeError
+            try:
+                method(standard=True)
+                method(standard=False)
+            except TypeError as e:
+                if "unexpected keyword argument 'standard'" in str(e):
+                    pytest.fail(f"Method {method_name} does not accept 'standard' parameter: {e}")
+                # Other TypeErrors might be expected (e.g., from mocked dependencies)
+            except Exception:
+                # Other exceptions are fine - we're only testing parameter acceptance
+                pass
+                
+    def test_standard_parameter_works(self):
+        """
+        Regression test: 'standard' parameter works correctly.
+        
+        This ensures the standard parameter continues to work.
+        """
+        from unittest.mock import patch
+        
+        # Test with income_statement as representative
+        with patch('edgar.xbrl.statements.StitchedStatement') as mock_stitched:
+            # Test standard parameter works
+            self.statements.income_statement(standard=True)
+            
+            # Verify the call was made with standard=True
+            args, kwargs = mock_stitched.call_args
+            standard_value = args[3]  # standard is 4th positional arg
+            
+            assert standard_value == True, "standard parameter should work correctly"
+            
+    def test_standard_false_works(self):
+        """
+        Test: 'standard=False' parameter works correctly.
+        
+        This ensures standard=False continues to work.
+        """
+        from unittest.mock import patch
+        
+        with patch('edgar.xbrl.statements.StitchedStatement') as mock_stitched:
+            # Test standard=False
+            self.statements.income_statement(standard=False)
+            
+            # Verify the call was made correctly
+            args, kwargs = mock_stitched.call_args
+            standard_value = args[3]  # standard is 4th positional arg
+            
+            assert standard_value == False, "standard=False parameter should work correctly"
+            
+    def test_parameter_defaults_regression(self):
+        """
+        Regression test: Parameter defaults must be maintained.
+        
+        This ensures default behavior doesn't change.
+        """
+        import inspect
+        
+        # Check parameter defaults for all methods
+        statement_methods = [
+            'income_statement',
+            'balance_sheet', 
+            'cashflow_statement',
+            'statement_of_equity',
+            'comprehensive_income'
+        ]
+        
+        for method_name in statement_methods:
+            method = getattr(self.statements, method_name)
+            sig = inspect.signature(method)
+            
+            # Verify defaults
+            assert sig.parameters['standard'].default == True, \
+                f"{method_name}: standard default should be True"
+
+
+def test_issue_403_does_not_regress():
+    """
+    Meta regression test: Ensure the original issue does not regress.
+    
+    This test simulates the original user's problem and ensures it stays fixed.
+    """
+    # Create a mock scenario like the original issue
+    mock_xbrls = MagicMock(spec=XBRLS)
+    statements = mock_xbrls.statements = StitchedStatements(mock_xbrls)
+    
+    # The original issue: This should not raise TypeError
+    try:
+        stmt = statements.income_statement(standard=True)
+        # Test passes if no exception is raised
+    except TypeError as e:
+        if "unexpected keyword argument 'standard'" in str(e):
+            pytest.fail(f"Issue #403 has regressed: {e}")
+        # Re-raise other TypeErrors that might be legitimate
+        raise
+
+
+if __name__ == "__main__":
+    print("Running regression tests for issue #403...")
+    pytest.main([__file__, "-v"])