stock_indicators/exceptions.py (1)

10-12:Resolve duplicateStockIndicatorsInitializationError definition across modules

There’s an existing class with the same name instock_indicators/_cslib/__init__.py, leading to handlers catching the “wrong” one depending on import path. Consolidate or rename so exactly one public class name is used project‑wide.

Two options:

• Single source of truth: define it here and import in_cslib/__init__.py, or
• Rename the_cslib one (e.g.,DotNetLibraryInitializationError) and update raises.

#!/bin/bash# Find all definitions/usages to update consistentlyrg -nP'class\s+StockIndicatorsInitializationError\b|StockIndicatorsInitializationError' -C2

stock_indicators/__init__.py (1)

19-25:Duplicate exception definition still needs resolution.

This exportsStockIndicatorsInitializationError fromstock_indicators.exceptions, but a previous review identified that this exception is defined in both:

• stock_indicators/exceptions.py (inheriting fromStockIndicatorsError)
• stock_indicators/_cslib/__init__.py (inheriting fromImportError)

This ambiguity must be resolved to ensure consistent exception handling across the library.

Resolution required:

1. Remove the duplicate definition fromstock_indicators/_cslib/__init__.py
2. ImportStockIndicatorsInitializationError fromstock_indicators.exceptions in_cslib/__init__.py
3. Ensure allraise StockIndicatorsInitializationError(...) calls use the imported exception

This ensures a single source of truth for the exception hierarchy.

stock_indicators/indicators/common/candles.py (1)

94-99:Cache guard should use identity check

if not self.__candle_prop_cache can incorrectly invalidate cache if the object defines falsey truthiness. Preferis None.

-        if not self.__candle_prop_cache:+        if self.__candle_prop_cache is None:

stock_indicators/_cstypes/list.py (2)

36-49:Align exceptions, iterability check, and population loop; minor Ruff fixes

• Use ValidationError/TypeConversionError to match the new taxonomy.
• Preferiter() try/except overhasattr('__iter__').
• Replacedeque(map(...)) with a clear for-loop; optionally preallocate capacity.
• Usetry/else to satisfy Ruff TRY300.

Apply:

-    def __new__(cls, generic: _T, sequence: Iterable) -> CsList:-        if not hasattr(sequence, '__iter__'):-            raise TypeError("sequence must be iterable")-        try:-            cs_list = CsList[generic]()-            # Always use individual Add calls for reliability-            # AddRange has issues with Python.NET type conversion in some cases-            deque(map(cs_list.Add, sequence), maxlen=0)-            return cs_list-        except Exception as e:-            raise ValueError(f"Cannot convert sequence to C# List[{generic}]: {e}") from e+    def __new__(cls, generic: type, sequence: Iterable) -> CsList:+        try:+            iterator = iter(sequence)+        except TypeError as e:+            # Defer import to avoid any potential import-cycle at module import time+            from stock_indicators.exceptions import ValidationError+            raise ValidationError("sequence must be iterable") from e++        # Optional: preallocate capacity if known+        cs_list = CsList[generic](len(sequence)) if hasattr(sequence, "__len__") else CsList[generic]()+        try:+            for item in iterator:+                cs_list.Add(item)+        except Exception as e:+            from stock_indicators.exceptions import TypeConversionError+            raise TypeConversionError(f"Cannot convert sequence to C# List[{generic}]: {e}") from e+        else:+            return cs_list

Optionally, add a type alias/overload forgeneric: type if your checker dislikesTypeVar here.

---

2-2:Typing nits (optional): tighten generics

Considerfrom typing import Iterable, Type and annotate asdef __new__(cls, generic: Type[_T], sequence: Iterable[_T]) -> CsList: for clearer intent to type checkers.

Also applies to: 6-7

stock_indicators/exceptions.py (1)

14-23:Consider inheriting from built-ins for catch-compatibility

For smoother interop with ecosystem code:

• TypeConversionError -> subclassTypeError too
• ValidationError -> subclassValueError (orTypeError depending on usage)

This preservesexcept TypeError/ValueError behavior while keeping your hierarchy.

-class TypeConversionError(StockIndicatorsError):+class TypeConversionError(TypeError, StockIndicatorsError):     """Raised when conversion between Python and C# types fails."""@@-class ValidationError(StockIndicatorsError):+class ValidationError(ValueError, StockIndicatorsError):     """Raised when input validation fails."""

stock_indicators/indicators/ema.py (1)

34-34:Clarify the inline comment about the assignment.

The comment states "Error occurs if not assigned to local var" but doesn't explain what error occurs or why. This makes it difficult for future maintainers to understand if the assignment is functionally required or just a workaround for the linter.

Consider updating the comment to be more explicit:

-    quotes = Quote.use(quotes, candle_part)  # pylint: disable=no-member  # Error occurs if not assigned to local var.+    quotes = Quote.use(quotes, candle_part)  # pylint: disable=no-member  # Assignment required: Quote.use returns modified quotes

Alternatively, if the assignment is solely for satisfying pylint and not functionally required, document that instead.

stock_indicators/indicators/macd.py (1)

42-42:Clarify the inline comment about the assignment.

Same issue as inema.py (Line 34): The comment "Error occurs if not assigned to local var" is vague and doesn't specify what error occurs or why the assignment is necessary.

Consider updating the comment for clarity:

-    quotes = Quote.use(quotes, candle_part)  # pylint: disable=no-member  # Error occurs if not assigned to local var.+    quotes = Quote.use(quotes, candle_part)  # pylint: disable=no-member  # Assignment required: Quote.use returns modified quotes

stock_indicators/indicators/sma.py (1)

35-37:Inconsistent pylint suppression formatting.

This file places thepylint: disable=no-member comment on a separate line (Line 35) before theQuote.use call, whileema.py andmacd.py use inline comments. This inconsistency makes the codebase harder to maintain.

For consistency, consider using the same inline format as in the other indicator files:

-    # pylint: disable=no-member  # Error occurs if not assigned to local var.-    quotes = Quote.use(-        quotes, candle_part)+    quotes = Quote.use(quotes, candle_part)  # pylint: disable=no-member

stock_indicators/indicators/common/helpers.py (2)

24-35:Consider using custom exceptions from the new exception hierarchy.

The validation logic is solid, but it raisesTypeError,ValueError, andRuntimeError. Given that this PR introduces a custom exception hierarchy (includingValidationError andIndicatorCalculationError fromstock_indicators.exceptions), consider using those for consistency:

 if remove_periods is not None:     if not isinstance(remove_periods, int):-        raise TypeError("remove_periods must be an integer")+        from stock_indicators.exceptions import ValidationError+        raise ValidationError("remove_periods must be an integer")     if remove_periods < 0:-        raise ValueError("remove_periods must be non-negative")+        raise ValidationError("remove_periods must be non-negative")     return super().remove_warmup_periods(remove_periods) try:     removed_results = CsIndicator.RemoveWarmupPeriods(CsList(self._get_csdata_type(), self._csdata))     return self.__class__(removed_results, self._wrapper_class) except Exception as e:-    raise RuntimeError(f"Failed to remove warmup periods: {e}") from e+    from stock_indicators.exceptions import IndicatorCalculationError+    raise IndicatorCalculationError(f"Failed to remove warmup periods: {e}") from e

This aligns with the exception hierarchy introduced in this PR and provides more semantic error types for library users to catch.

---

51-63:Consider using custom exceptions for consistency.

Similar toremove_warmup_periods, thecondense method could benefit from using the custom exception hierarchy:

 try:     # Try to find the specific overloaded method first     try:         condense_method = CsIndicator.Condense.Overloads[CsIEnumerable[cs_results_type]]     except TypeError:         # Fall back to generic utility method         condense_method = CsResultUtility.Condense[cs_results_type]     condensed_results = condense_method(CsList(cs_results_type, self._csdata))     return self.__class__(condensed_results, self._wrapper_class) except Exception as e:-    raise RuntimeError(f"Failed to condense results: {e}") from e+    from stock_indicators.exceptions import IndicatorCalculationError+    raise IndicatorCalculationError(f"Failed to condense results: {e}") from e

stock_indicators/indicators/common/results.py (1)

78-86:Consider using custom exceptions for consistency.

While the error messages are clear and helpful, consider using custom exceptions fromstock_indicators.exceptions for consistency with the rest of the PR:

         def verify_data(self, *args):             if self._csdata is None:                 # Use a generic name when func.__name__ is not available                 func_name = getattr(func, '__name__', 'method')-                raise ValueError(f"Cannot {func_name}() after done() has been called. Call reload() first.")+                from stock_indicators.exceptions import ValidationError+                raise ValidationError(f"Cannot {func_name}() after done() has been called. Call reload() first.")             if not isinstance(self._csdata, Iterable) or len(self) < 1:                 # Use a generic name when func.__name__ is not available                 func_name = getattr(func, '__name__', 'method')-                raise ValueError(f"Cannot {func_name}() an empty result.")+                raise ValidationError(f"Cannot {func_name}() an empty result.")

This aligns with the custom exception hierarchy introduced in this PR.

stock_indicators/indicators/vwap.py (2)

18-19:Signature mixes defaulted arg before varargs; keep API but tighten validation and silence linters

The current signature preserves backward compatibility but triggers static analysis. I recommend keeping it (to avoid breaking positionalstart), and instead address lint by improving the legacy parsing block (see next comment) and, if needed, adding a local disable for the Codacy rule on this line.

---

62-62:Prefer explicit None check to avoid truthiness ambiguity

Useis not None to avoid accidental truthiness checks.

-    results = CsIndicator.GetVwap[Quote](CsList(Quote, quotes), CsDateTime(start_dt) if start_dt else None)+    results = CsIndicator.GetVwap[Quote](CsList(Quote, quotes), CsDateTime(start_dt) if start_dt is not None else None)

stock_indicators/indicators/ichimoku.py (1)

46-54:Docstring: minor wording fix

“Number of periods in displace the Chikou Span.” → “Number of periods to displace the Chikou Span.”

stock_indicators/_cslib/__init__.py (3)

60-73:Preferclr.AddReference(path) overAssembly.LoadFile to avoid load-context issues

Assembly.LoadFile can create a separate load context and lock the file. Python.NET commonly usesclr.AddReference(str(dll_path)) which both loads and references in one step and plays nicer with .NET Core load contexts.

Example:

-def _load_assembly(assembly_dll_path: Path):+def _load_assembly(assembly_dll_path: Path, clr_module):@@-    from System.Reflection import Assembly@@-    logger.debug("Loading assembly from: %s", assembly_dll_path)-    loaded_assembly = Assembly.LoadFile(str(assembly_dll_path))-    logger.debug("Assembly loaded: %s", loaded_assembly.FullName)-    return loaded_assembly+    logger.debug("Loading assembly via clr.AddReference: %s", assembly_dll_path)+    loaded = clr_module.AddReference(str(assembly_dll_path))  # returns Assembly object+    logger.debug("Assembly loaded: %s", loaded.FullName)+    return loaded

Then call as:assembly = _load_assembly(dll_path, clr).

---

55-58:Broad except justified for interop; downgrade severity to log.debug

The warning may be noisy on platforms where probing path is irrelevant. Consider logging at debug level, keeping the broad catch.

-        logger.warning("Failed to set assembly probing path: %s", str(e))+        logger.debug("Skipped setting assembly probing path: %s", e, exc_info=False)

---

37-43:Style nits: f-string conversion flags and message length

Use!s in f-strings and keep messages concise per TRY003/RUF010.

Examples:

-            f"Error: {str(e)}"+            f"Error: {e!s}"

Repeat similarly in other blocks.

Also applies to: 75-79, 88-92, 115-121, 153-158

stock_indicators/indicators/common/quote.py (3)

34-40:Setters accept multiple numeric types; consider explicit parse errors for str inputs

Right now errors bubble from CsDecimal. Optionally wrap with a concise ValueError to standardize messaging for invalid strings.

-    if value is not None:-        quote.Open = CsDecimal(value)+    if value is not None:+        try:+            quote.Open = CsDecimal(value)+        except Exception as e:+            raise ValueError(f"Invalid open value: {value!r}") from e

Apply similarly to high/low/close/volume if desired.

Also applies to: 47-51, 58-62, 69-73, 80-84

---

22-22:Minor lint: trailing whitespace and TRY003 messages

• Remove the trailing whitespace on Line 22.
• Current exception messages are fine; if you want to appease TRY003, shorten them slightly or centralize in constants.

Also applies to: 114-114, 133-133, 158-160, 165-165

---

157-165:Iterable check: prefercollections.abc.Iterable

hasattr(quotes, '__iter__') will treat strings as iterable. If strings should be rejected, add an explicit check.

-        if not hasattr(quotes, '__iter__'):+        from collections.abc import Iterable as _Iterable+        if not isinstance(quotes, _Iterable) or isinstance(quotes, (str, bytes)):             raise TypeError("quotes must be iterable")

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

stock_indicators/indicators/ichimoku.py (1)

65-70:Prevent ambiguous parameter mixing.

The current logic allows mixingoffset_periods with explicitsenkou_offset orchikou_offset, which creates ambiguity. For example, calling withoffset_periods=10, senkou_offset=20, chikou_offset=30 silently ignoresoffset_periods. A previous review suggested raising an error to prevent this confusion.

Apply this diff to enforce mutual exclusivity:

-    # Normalize offset_periods into senkou_offset and chikou_offset     if offset_periods is not None:-        if senkou_offset is None:-            senkou_offset = offset_periods-        if chikou_offset is None:-            chikou_offset = offset_periods+        if senkou_offset is not None or chikou_offset is not None:+            raise TypeError(+                "Provide either offset_periods or (senkou_offset/chikou_offset), not both"+            )+        senkou_offset = chikou_offset = offset_periods

stock_indicators/indicators/ichimoku.py (1)

48-55:Document parameter interaction and mutual exclusivity.

The docstring should clarify the relationship betweenoffset_periods and the individualsenkou_offset/chikou_offset parameters. Consider adding a note explaining thatoffset_periods is a convenience parameter that sets both offsets to the same value, and that it should not be mixed with explicit offset parameters.

Example addition to the docstring:

         `offset_periods` : int-            Number of periods to displace the Senkou and Chikou Spans.+            Number of periods to displace the Senkou and Chikou Spans.+            This is a convenience parameter that sets both senkou_offset and chikou_offset+            to the same value. Cannot be used with explicit senkou_offset or chikou_offset.          `senkou_offset` : int-            Number of periods to displace the Senkou Spans.+            Number of periods to displace the Senkou Spans.+            Cannot be used with offset_periods.          `chikou_offset` : int-            Number of periods in displace the Chikou Span.+            Number of periods to displace the Chikou Span.+            Cannot be used with offset_periods.

stock_indicators/indicators/vwap.py (1)

44-109:Thorough validation; consider extracting duplicate range checks.

The extensive validation provides clear error messages and prevents invalid datetime construction, addressing the maintainer's prior feedback. The implementation correctly handles both legacy positional and keyword-based date specification.

Consider extracting the duplicate month/day/hour/minute range validation (lines 77-84 and 94-101) into a helper function to reduce redundancy:

def_validate_date_components(month:int,day:int,hour:int,minute:int)->None:"""Validate date component ranges."""ifnot1<=month<=12:raiseValueError(f"Month must be 1-12, got{month}")ifnot1<=day<=31:raiseValueError(f"Day must be 1-31, got{day}")ifnot0<=hour<=23:raiseValueError(f"Hour must be 0-23, got{hour}")ifnot0<=minute<=59:raiseValueError(f"Minute must be 0-59, got{minute}")

Then call_validate_date_components(month, day, hour, minute) at lines 77 and 94.

stock_indicators/indicators/sma.py (1)

35-37:Scope the pylint suppression to the exact line

Move the disable pragma onto the assignment line to minimize scope and avoid muting future false positives.

-    # pylint: disable=no-member  # Error occurs if not assigned to local var.-    quotes = Quote.use(-        quotes, candle_part)+    quotes = Quote.use(  # pylint: disable=no-member  # dynamic attr via pythonnet+        quotes, candle_part)

stock_indicators/indicators/alligator.py (1)

10-13:LGTM on targeted lint suppression

Keeping signature unchanged while silencing PLR0913 is fine for compatibility. Consider documenting in docstring that callers should prefer keyword args to reduce ordering mistakes.

stock_indicators/indicators/common/helpers.py (1)

24-29:Input validation is good; preserve bool semantics intentionally

Type/range checks are correct. If you want to proactively reject bools (since bool is a subclass of int), add an explicit guard; otherwise current behavior will raise during downstream conversion when given True/False.

         if remove_periods is not None:-            if not isinstance(remove_periods, int):+            if not isinstance(remove_periods, int) or isinstance(remove_periods, bool):                 raise TypeError("remove_periods must be an integer")

stock_indicators/__init__.py (1)

19-25:Define all to make exports explicit and silence F401 in init

Explicit exports stabilize the public API and quiet “imported but unused” lint.

 from stock_indicators.indicators.common import * from stock_indicators.exceptions import (     StockIndicatorsError,     StockIndicatorsInitializationError,     TypeConversionError,     IndicatorCalculationError,     ValidationError )++__all__ = [+    # subpackages+    "indicators",+    # exceptions+    "StockIndicatorsError",+    "StockIndicatorsInitializationError",+    "TypeConversionError",+    "IndicatorCalculationError",+    "ValidationError",+    # re-exported from indicators.common via star-import (keep stable list if preferred)+]

stock_indicators/_cstypes/decimal.py (2)

24-35:Solid conversion path; tighten messages and avoid re-import churn

Keep error text concise (TRY003) and import exceptions once at module top to reduce import overhead.

-from stock_indicators._cslib import CsDecimal, CsCultureInfo, CsNumberStyles+from stock_indicators._cslib import CsDecimal, CsCultureInfo, CsNumberStyles+from stock_indicators.exceptions import TypeConversionError, ValidationError@@-    def __new__(cls, decimal: Union[int, float, PyDecimal, str, None]) -> CsDecimal:+    def __new__(cls, decimal: Union[int, float, PyDecimal, str, None]) -> CsDecimal:         if decimal is None:-            from stock_indicators.exceptions import ValidationError-            raise ValidationError("Cannot convert None to C# Decimal")+            raise ValidationError("Cannot convert None to C# Decimal")@@-        except Exception as e:-            from stock_indicators.exceptions import TypeConversionError-            raise TypeConversionError(f"Cannot convert {decimal} (type: {type(decimal)}) to C# Decimal: {e}") from e+        except Exception as e:+            raise TypeConversionError("Cannot convert value to C# Decimal") from e

---

37-54:None-safe to_pydecimal is good; align error type/message with above

Match the concise message and module-level import.

-    except Exception as e:-        from stock_indicators.exceptions import TypeConversionError-        raise TypeConversionError(f"Cannot convert C# Decimal to Python Decimal: {e}") from e+    except Exception as e:+        raise TypeConversionError("Cannot convert C# Decimal to Python Decimal") from e

stock_indicators/_cslib/__init__.py (4)

29-44:CLR init path: good structure; shorten error text to satisfy linters

The flow is solid. Consider shorter messages to quiet TRY003 and keep details in the chained exception.

-        init_error_msg = (-            "Failed to load .NET CLR runtime.\n"-            "Please ensure .NET 6.0+ is installed: https://dotnet.microsoft.com/download\n"-            f"Platform: {platform.system()}\n"-            f"Error: {str(e)}"-        )-        raise StockIndicatorsInitializationError(init_error_msg) from e+        raise StockIndicatorsInitializationError("Failed to load .NET CLR runtime") from e

---

100-108:Make assembly path resolution packaging‑robust

Relative paths can break in zipped installs. Prefer importlib.resources (or files) to locate bundled DLLs.

-    base_path = Path(__file__).parent.resolve()-    dll_path = base_path / "lib" / "Skender.Stock.Indicators.dll"+    try:+        from importlib.resources import files+        dll_path = files(__package__) / "lib" / "Skender.Stock.Indicators.dll"+        dll_path = Path(dll_path)+    except Exception:+        # Fallback to filesystem path+        base_path = Path(__file__).parent.resolve()+        dll_path = base_path / "lib" / "Skender.Stock.Indicators.dll"

---

112-121:Wrap unexpected exceptions but keep original types for known ones

Logic is correct. Consider logging the traceback at debug level to aid field diagnostics.

---

152-158:Re-raise as initialization error: keep message concise

Shorten the message; chain preserves details.

-    error_msg = (-        "Failed to import Stock Indicators types after successful assembly loading.\n"-        "This may indicate a version mismatch or missing dependencies.\n"-        f"Error: {str(e)}"-    )-    raise StockIndicatorsInitializationError(error_msg) from e+    raise StockIndicatorsInitializationError("Failed to import Stock Indicators types") from e

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro