pytafast 0.1.0__tar.gz

pytafast-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.pytest_cache
+.benchmarks

pytafast-0.1.0/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "third_party/nanobind"]
+	path = third_party/nanobind
+	url = https://github.com/wjakob/nanobind
+[submodule "third_party/ta-lib"]
+	path = third_party/ta-lib
+	url = https://github.com/TA-Lib/ta-lib

pytafast-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

pytafast-0.1.0/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.15...3.27)
+project(pytalib VERSION 0.1.0)
+
+# Build ta-lib
+# ta-lib provides a configure script, but CMake can build it directly if we list its sources.
+# Since ta-lib v0.6.4 is already a robust C library, a clean approach is either to use its configure/make (ExternalProject_Add) 
+# or just compile its `src` folder directly. Let's use `add_subdirectory` if it has CMake, else we build the sources.
+# Let's inspect ta-lib after checkout.
+add_subdirectory(third_party/ta-lib)
+
+# include nanobind
+find_package(Python 3.11 COMPONENTS Interpreter Development.Module REQUIRED)
+add_subdirectory(third_party/nanobind)
+
+# The main python module
+nanobind_add_module(pytafast_ext src/pytafast_ext.cpp)
+
+# Link against ta-lib
+target_link_libraries(pytafast_ext PRIVATE ta-lib-static)
+
+# Install extension in package
+install(TARGETS pytafast_ext DESTINATION pytafast)

pytafast-0.1.0/GEMINI.md

@@ -0,0 +1,70 @@
+# pytafast
+
+A high-performance Python wrapper for the `ta-lib` C library using `nanobind`.
+
+## Project Overview
+
+- **Core Technology:** Uses `nanobind` for efficient C++/Python bindings and `scikit-build-core` for the build system.
+- **Architecture:** 
+    - A C++ extension (`pytafast_ext`) wraps the raw `ta-lib` functions.
+    - A Python layer (`pytafast`) provides a high-level API that supports both `numpy` arrays and `pandas` Series.
+- **Key Features:**
+    - Preservation of `pandas.Series` metadata (index, name).
+    - Automatic `TA_Initialize()` and `TA_Shutdown()` management.
+    - Performance-oriented, utilizing `nb::ndarray` for zero-copy data access where possible.
+
+## Building and Running
+
+### Prerequisites
+
+- C++ compiler (supporting C++17 or later)
+- CMake (3.15+)
+- Python (3.11+)
+
+### Installation
+
+For development, it is recommended to use `uv` or `pip` in editable mode:
+
+```bash
+# Using uv (recommended)
+uv pip install -v -e .
+
+# Using pip
+pip install -v -e .
+```
+
+The `-v` flag is helpful to see the CMake build output.
+
+### Testing
+
+Tests are managed with `pytest`.
+
+```bash
+# Run all tests
+pytest
+
+# Run tests with benchmarking
+pytest tests/test_benchmark.py
+```
+
+## Development Conventions
+
+### Project Structure
+
+- `src/pytafast_ext.cpp`: The main C++ binding file. All `ta-lib` function wrappings should be added here.
+- `src/pytafast/__init__.py`: The public Python API. New functions added to the C++ extension should be exposed here with appropriate documentation and type handling.
+- `third_party/`: Contains git submodules for `ta-lib` and `nanobind`.
+- `tests/`: Contains `pytest` test cases.
+
+### Coding Standards
+
+- **C++:**
+    - Use `nanobind` (`nb::ndarray`) for array passing.
+    - Use `check_ta_retcode` to handle `TA_RetCode` and raise appropriate Python exceptions.
+    - Ensure memory safety by using `nb::capsule` for data ownership when returning arrays allocated in C++.
+- **Python:**
+    - Support both `numpy.ndarray` and `pandas.Series` in public functions.
+    - Achieve true zero-copy data passing by ensuring array continuity (`np.ascontiguousarray`) and explicitly typing C++ arguments as `const double` references (`nb::ndarray<nb::numpy, const double, nb::c_contig>`) which safely accepts Pandas' read-only memory views without enforcing deep copies.
+- **Testing:**
+    - Always compare results against the official `TA-Lib` Python package for verification.
+    - Include benchmarks for new functions to ensure performance remains competitive.

pytafast-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: pytafast
+Version: 0.1.0
+Summary: Python wrapper for ta-lib using nanobind
+Author-Email: curry tang <twn39@163.com>
+Requires-Python: >=3.11
+Requires-Dist: numpy
+Requires-Dist: pandas
+Description-Content-Type: text/markdown
+

pytafast-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["scikit-build-core>=0.4.3", "nanobind>=2.11.0"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "pytafast"
+version = "0.1.0"
+description = "Python wrapper for ta-lib using nanobind"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "numpy",
+    "pandas"
+]
+authors = [
+  {name = "curry tang", email = "twn39@163.com"}
+]
+
+[tool.scikit-build]
+minimum-version = "0.4"
+cmake.build-type = "Release"
+sdist.include = [
+    "third_party/ta-lib/src/**/*",
+    "third_party/ta-lib/include/**/*",
+    "third_party/ta-lib/CMakeLists.txt",
+    "third_party/ta-lib/ta_lib.cmake", 
+    "third_party/ta-lib/ta-lib-config.cmake.in",
+    "third_party/nanobind/src/**/*",
+    "third_party/nanobind/include/**/*",
+    "third_party/nanobind/ext/**/*",
+    "third_party/nanobind/cmake/**/*",
+    "third_party/nanobind/CMakeLists.txt",
+]
+sdist.exclude = [
+    "third_party/ta-lib/ide/**/*",
+    "third_party/ta-lib/dist/**/*",
+    "third_party/ta-lib/dotnet/**/*",
+    "third_party/ta-lib/java/**/*",
+    "third_party/ta-lib/docs/**/*",
+    "third_party/ta-lib/swig/**/*",
+    "third_party/nanobind/docs/**/*",
+    "third_party/**/*.deb",
+    "third_party/**/*.msi",
+    "third_party/**/*.zip",
+    "third_party/**/*.dll",
+    "third_party/**/*.class",
+    "third_party/**/*.pdf",
+    "third_party/**/*.sdf",
+]
+
+[dependency-groups]
+dev = [
+    "ta-lib>=0.6.8",
+    "pytest-benchmark>=4.0.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pytafast-0.1.0/src/pytafast/__init__.py

@@ -0,0 +1,197 @@
+import numpy as np
+
+# We import the compiled extension module
+from . import pytafast_ext
+from .pytafast_ext import MAType
+
+__version__ = "0.1.0"
+
+def _is_pandas_series(obj):
+    try:
+        import pandas as pd
+        return isinstance(obj, pd.Series)
+    except ImportError:
+        return False
+
+def SMA(inReal, timeperiod=30):
+    """
+    Simple Moving Average.
+    
+    Args:
+        inReal: 1D array-like (numpy ndarray, pandas Series, list, etc.) of floats.
+        timeperiod: Integer time period.
+        
+    Returns:
+        A numpy array or pandas Series (matching input) with the SMA values.
+        The leading (timeperiod - 1) elements will be NaN.
+    """
+    is_series = _is_pandas_series(inReal)
+    
+    # We use copy=False and ascontiguousarray to achieve zero-copy whenever possible
+    arr = np.asarray(inReal, dtype=np.float64)
+    arr = np.ascontiguousarray(arr)
+    
+    # Call the C++ nanobind wrapper
+    out_arr = pytafast_ext.SMA(arr, timeperiod)
+    
+    # Cast back to pandas Series if input was a Series
+    if is_series:
+        import pandas as pd
+        return pd.Series(out_arr, index=inReal.index, name=inReal.name)
+    
+    return out_arr
+
+def EMA(inReal, timeperiod=30):
+    """
+    Exponential Moving Average.
+    """
+    is_series = _is_pandas_series(inReal)
+    arr = np.ascontiguousarray(np.asarray(inReal, dtype=np.float64))
+    out_arr = pytafast_ext.EMA(arr, timeperiod)
+    if is_series:
+        import pandas as pd
+        return pd.Series(out_arr, index=inReal.index, name=inReal.name)
+    return out_arr
+
+def RSI(inReal, timeperiod=14):
+    """
+    Relative Strength Index.
+    """
+    is_series = _is_pandas_series(inReal)
+    arr = np.ascontiguousarray(np.asarray(inReal, dtype=np.float64))
+    out_arr = pytafast_ext.RSI(arr, timeperiod)
+    if is_series:
+        import pandas as pd
+        return pd.Series(out_arr, index=inReal.index, name=inReal.name)
+    return out_arr
+
+def MACD(inReal, fastperiod=12, slowperiod=26, signalperiod=9):
+    """
+    Moving Average Convergence/Divergence.
+    Returns: (macd, macdsignal, macdhist)
+    """
+    is_series = _is_pandas_series(inReal)
+    arr = np.ascontiguousarray(np.asarray(inReal, dtype=np.float64))
+    macd, macdsignal, macdhist = pytafast_ext.MACD(arr, fastperiod, slowperiod, signalperiod)
+    if is_series:
+        import pandas as pd
+        return (
+            pd.Series(macd, index=inReal.index, name="MACD"),
+            pd.Series(macdsignal, index=inReal.index, name="MACD_Signal"),
+            pd.Series(macdhist, index=inReal.index, name="MACD_Hist")
+        )
+    return macd, macdsignal, macdhist
+
+def BBANDS(inReal, timeperiod=5, nbdevup=2.0, nbdevdn=2.0, matype=MAType.SMA):
+    """
+    Bollinger Bands.
+    Returns: (upperband, middleband, lowerband)
+    """
+    is_series = _is_pandas_series(inReal)
+    arr = np.ascontiguousarray(np.asarray(inReal, dtype=np.float64))
+    # Convert Enum to int for C++ call if necessary, though nanobind handles enum bindings
+    upper, middle, lower = pytafast_ext.BBANDS(arr, timeperiod, nbdevup, nbdevdn, int(matype.value) if hasattr(matype, 'value') else int(matype))
+    
+    if is_series:
+        import pandas as pd
+        return (
+            pd.Series(upper, index=inReal.index, name="UpperBand"),
+            pd.Series(middle, index=inReal.index, name="MiddleBand"),
+            pd.Series(lower, index=inReal.index, name="LowerBand")
+        )
+    return upper, middle, lower
+
+def ATR(inHigh, inLow, inClose, timeperiod=14):
+    """
+    Average True Range.
+    """
+    is_series = _is_pandas_series(inClose)
+    arr_h = np.ascontiguousarray(np.asarray(inHigh, dtype=np.float64))
+    arr_l = np.ascontiguousarray(np.asarray(inLow, dtype=np.float64))
+    arr_c = np.ascontiguousarray(np.asarray(inClose, dtype=np.float64))
+    out_arr = pytafast_ext.ATR(arr_h, arr_l, arr_c, timeperiod)
+    if is_series:
+        import pandas as pd
+        return pd.Series(out_arr, index=inClose.index, name="ATR")
+    return out_arr
+
+def ADX(inHigh, inLow, inClose, timeperiod=14):
+    """
+    Average Directional Movement Index.
+    """
+    is_series = _is_pandas_series(inClose)
+    arr_h = np.ascontiguousarray(np.asarray(inHigh, dtype=np.float64))
+    arr_l = np.ascontiguousarray(np.asarray(inLow, dtype=np.float64))
+    arr_c = np.ascontiguousarray(np.asarray(inClose, dtype=np.float64))
+    out_arr = pytafast_ext.ADX(arr_h, arr_l, arr_c, timeperiod)
+    if is_series:
+        import pandas as pd
+        return pd.Series(out_arr, index=inClose.index, name="ADX")
+    return out_arr
+
+def CCI(inHigh, inLow, inClose, timeperiod=14):
+    """
+    Commodity Channel Index.
+    """
+    is_series = _is_pandas_series(inClose)
+    arr_h = np.ascontiguousarray(np.asarray(inHigh, dtype=np.float64))
+    arr_l = np.ascontiguousarray(np.asarray(inLow, dtype=np.float64))
+    arr_c = np.ascontiguousarray(np.asarray(inClose, dtype=np.float64))
+    out_arr = pytafast_ext.CCI(arr_h, arr_l, arr_c, timeperiod)
+    if is_series:
+        import pandas as pd
+        return pd.Series(out_arr, index=inClose.index, name="CCI")
+    return out_arr
+
+def OBV(inReal, inVolume):
+    """
+    On Balance Volume.
+    """
+    is_series = _is_pandas_series(inReal)
+    arr_c = np.ascontiguousarray(np.asarray(inReal, dtype=np.float64))
+    arr_v = np.ascontiguousarray(np.asarray(inVolume, dtype=np.float64))
+    out_arr = pytafast_ext.OBV(arr_c, arr_v)
+    if is_series:
+        import pandas as pd
+        return pd.Series(out_arr, index=inReal.index, name="OBV")
+    return out_arr
+
+def ROC(inReal, timeperiod=10):
+    """
+    Rate of change : ((price/prevPrice)-1)*100
+    """
+    is_series = _is_pandas_series(inReal)
+    arr = np.ascontiguousarray(np.asarray(inReal, dtype=np.float64))
+    out_arr = pytafast_ext.ROC(arr, timeperiod)
+    if is_series:
+        import pandas as pd
+        return pd.Series(out_arr, index=inReal.index, name="ROC")
+    return out_arr
+
+def STOCH(inHigh, inLow, inClose, fastk_period=5, slowk_period=3, slowk_matype=MAType.SMA, slowd_period=3, slowd_matype=MAType.SMA):
+    """
+    Stochastic.
+    Returns: (slowk, slowd)
+    """
+    is_series = _is_pandas_series(inClose)
+    arr_h = np.ascontiguousarray(np.asarray(inHigh, dtype=np.float64))
+    arr_l = np.ascontiguousarray(np.asarray(inLow, dtype=np.float64))
+    arr_c = np.ascontiguousarray(np.asarray(inClose, dtype=np.float64))
+    
+    sk_t = int(slowk_matype.value) if hasattr(slowk_matype, 'value') else int(slowk_matype)
+    sd_t = int(slowd_matype.value) if hasattr(slowd_matype, 'value') else int(slowd_matype)
+    
+    slowk, slowd = pytafast_ext.STOCH(arr_h, arr_l, arr_c, fastk_period, slowk_period, sk_t, slowd_period, sd_t)
+    
+    if is_series:
+        import pandas as pd
+        return (
+            pd.Series(slowk, index=inClose.index, name="SlowK"),
+            pd.Series(slowd, index=inClose.index, name="SlowD")
+        )
+    return slowk, slowd
+
+# Initialize TA-Lib context when the module is loaded
+pytafast_ext.initialize()
+
+from pytafast import aio

pytafast-0.1.0/src/pytafast/aio.py

@@ -0,0 +1,35 @@
+import asyncio
+import pytafast
+
+async def SMA(*args, **kwargs):
+    return await asyncio.to_thread(pytafast.SMA, *args, **kwargs)
+
+async def EMA(*args, **kwargs):
+    return await asyncio.to_thread(pytafast.EMA, *args, **kwargs)
+
+async def RSI(*args, **kwargs):
+    return await asyncio.to_thread(pytafast.RSI, *args, **kwargs)
+
+async def MACD(*args, **kwargs):
+    return await asyncio.to_thread(pytafast.MACD, *args, **kwargs)
+
+async def BBANDS(*args, **kwargs):
+    return await asyncio.to_thread(pytafast.BBANDS, *args, **kwargs)
+
+async def ATR(*args, **kwargs):
+    return await asyncio.to_thread(pytafast.ATR, *args, **kwargs)
+
+async def ADX(*args, **kwargs):
+    return await asyncio.to_thread(pytafast.ADX, *args, **kwargs)
+
+async def CCI(*args, **kwargs):
+    return await asyncio.to_thread(pytafast.CCI, *args, **kwargs)
+
+async def OBV(*args, **kwargs):
+    return await asyncio.to_thread(pytafast.OBV, *args, **kwargs)
+
+async def ROC(*args, **kwargs):
+    return await asyncio.to_thread(pytafast.ROC, *args, **kwargs)
+
+async def STOCH(*args, **kwargs):
+    return await asyncio.to_thread(pytafast.STOCH, *args, **kwargs)