qutePandas 1.1.0__tar.gz → 1.1.1__tar.gz

{qutepandas-1.1.0/qutePandas.egg-info → qutepandas-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qutePandas
-Version: 1.1.0
+Version: 1.1.1
 Summary: A pandas-like library for kdb+/q using pykx
 Home-page: https://ishapatro.github.io/qutePandas/
 Author: Isha Patro

{qutepandas-1.1.0 → qutepandas-1.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qutePandas"
-version = "1.1.0"
+version = "1.1.1"
 authors = [
   { name="Isha Patro", email="ishapatro21@gmail.com" },
 ]

{qutepandas-1.1.0 → qutepandas-1.1.1}/qutePandas/__init__.py

@@ -1,11 +1,11 @@
-"""
-qutePandas - A pandas-like library for q/kdb+
-"""
-
 import os
+import sys
 
-def _setup_environment():
-    """Validates and sets up the environment for PyKX."""
+def _setup_pykx_environment():
+    """
+    Sets up the environment for PyKX BEFORE any PyKX imports.
+    This must run before importing any module that uses PyKX.
+    """
     root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
     env_path = os.path.join(root, ".env")
     
@@ -20,17 +20,47 @@ def _setup_environment():
                     if len(parts) == 2:
                         key, value = parts
                         value = value.strip().strip('"').strip("'")
+                        # Only set if not already in environment
                         if key.strip() and key.strip() not in os.environ:
                             os.environ[key.strip()] = value
-
+    
+    # Check for valid license files in priority order
     qutepandas_home = os.path.expanduser("~/.qutepandas")
     local_kdb = os.path.join(root, "kdb_lic")
+    
+    license_found = False
+    valid_license_path = None
+    
     if os.path.exists(os.path.join(local_kdb, "kc.lic")):
-        os.environ['QLIC'] = local_kdb
+        valid_license_path = local_kdb
+        license_found = True
     elif os.path.exists(os.path.join(qutepandas_home, "kc.lic")):
-        os.environ['QLIC'] = qutepandas_home
+        valid_license_path = qutepandas_home
+        license_found = True
+    
+    if license_found and valid_license_path:
+        os.environ['QLIC'] = valid_license_path
+        os.environ.pop('PYKX_UNLICENSED', None)
+    elif 'QLIC' in os.environ:
+        qlic_path = os.environ['QLIC']
+        if not (os.path.exists(os.path.join(qlic_path, "kc.lic")) or 
+                os.path.exists(os.path.join(qlic_path, "k4.lic"))):
+            del os.environ['QLIC']
+            if 'QHOME' in os.environ:
+                del os.environ['QHOME']
+            license_found = False
+    
+    if not license_found and 'PYKX_UNLICENSED' not in os.environ:
+        os.environ['PYKX_UNLICENSED'] = 'true'
+    
+    if 'PYKX_RELEASE_GIL' not in os.environ:
+        os.environ['PYKX_RELEASE_GIL'] = 'true'
+    
+    if 'PYKX_ENFORCE_EMBEDDED_IMPORT' not in os.environ:
+        os.environ['PYKX_ENFORCE_EMBEDDED_IMPORT'] = '0'
+
+_setup_pykx_environment()
 
-_setup_environment()
 from .core.dataframe import DataFrame
 from .core.connection import connect, get_license_info, install_license
 from .core.display import py, np, pd, pa, pt, print
@@ -59,4 +89,4 @@ from .introspection.dtypes import dtypes
 
 from .indexing import loc, iloc
 
-__version__ = "1.0.0"
+__version__ = "1.1.1"

{qutepandas-1.1.0 → qutepandas-1.1.1}/qutePandas/apply/apply.py

@@ -2,6 +2,10 @@ import pykx as kx
 import pandas as pd
 from ..utils import _ensure_q_table, _handle_return
 
+_VECTORIZED_AXIS1 = {
+    'sum': '{sum (0^) each value flip x}',
+}
+
 
 def apply(df, func, axis=0, return_type='q'):
     """
@@ -39,7 +43,9 @@ def apply(df, func, axis=0, return_type='q'):
                 return pd.Series(ret) if return_type == 'p' else ret
 
         if isinstance(func, str):
-            if axis == 1:
+            if axis == 1 and func in _VECTORIZED_AXIS1:
+                result = kx.q(_VECTORIZED_AXIS1[func], q_table)
+            elif axis == 1:
                 result = kx.q(f"{{({func}) each x}}", q_table)
             else:
                 result = kx.q(f"{{({func}) each flip x}}", q_table)

qutepandas-1.1.1/qutePandas/cleaning/fillna.py

@@ -0,0 +1,49 @@
+import pykx as kx
+import pandas as pd
+from ..utils import _ensure_q_table, _handle_return
+
+def fillna(df, col_or_values, fill_value=None, return_type='q'):
+    """
+    Fills null values in specified columns.
+
+    Can be called in two ways:
+        fillna(df, values_dict, return_type='q')
+        fillna(df, col_name, fill_value, return_type='q')
+
+    Parameters
+    ----------
+    df : pandas.DataFrame or pykx.Table
+        Input DataFrame.
+    col_or_values : str or dict
+        If str, the column name to fill (requires fill_value).
+        If dict, a mapping of column names to fill values.
+    fill_value : scalar, optional
+        The value to fill nulls with when col_or_values is a column name.
+    return_type : str, default 'q'
+        Desired return type ('p' or 'q').
+
+    Returns
+    -------
+    pandas.DataFrame or pykx.Table
+        DataFrame with nulls filled.
+    """
+    try:
+        if isinstance(col_or_values, str):
+            if fill_value is None:
+                raise ValueError("fill_value is required when col_or_values is a column name")
+            values = {col_or_values: fill_value}
+        elif isinstance(col_or_values, dict):
+            values = col_or_values
+        else:
+            raise ValueError("col_or_values must be a column name (str) or a dictionary")
+
+        q_table = _ensure_q_table(df)
+        result = q_table
+
+        for col, val in values.items():
+            fill_val = f'`{val}' if isinstance(val, str) else str(val)
+            result = kx.q(f"{{update {col}:{fill_val}^{col} from x}}", result)
+
+        return _handle_return(result, return_type)
+    except Exception as e:
+        raise RuntimeError(f"Failed to fillna: {e}")

{qutepandas-1.1.0 → qutepandas-1.1.1}/qutePandas/core/dataframe.py

@@ -1,11 +1,8 @@
 import pykx as kx
 import pandas as pd
-import os
 import atexit
 from ..utils import _handle_return
 
-os.environ['PYKX_ENFORCE_EMBEDDED_IMPORT'] = '0'
-
 def DataFrame(data, columns=None):
     """
     Creates a qutePandas DataFrame (internal pykx Table).

{qutepandas-1.1.0 → qutepandas-1.1.1}/qutePandas/indexing/iloc.py

@@ -22,10 +22,15 @@ def iloc(df, rows=None, cols=None, return_type='q'):
         Subset of the inputs.
     """
     table = _ensure_q_table(df)
-    
+
     count = kx.q("count", table).py()
     all_cols = kx.q("cols", table).py()
-    
+
+    # Track whether we can use the fast sublist path for contiguous row slices
+    _use_sublist = False
+    _slice_start = 0
+    _slice_count = 0
+
     if rows is None:
         row_indices = None
     elif isinstance(rows, int):
@@ -33,7 +38,14 @@ def iloc(df, rows=None, cols=None, return_type='q'):
         if q_rows < 0: q_rows += count
         row_indices = [q_rows]
     elif isinstance(rows, slice):
-        row_indices = list(range(*rows.indices(count)))
+        start, stop, step = rows.indices(count)
+        if step == 1:
+            _use_sublist = True
+            _slice_start = start
+            _slice_count = stop - start
+            row_indices = None  # Not needed — sublist handles it
+        else:
+            row_indices = list(range(start, stop, step))
     else:
         row_indices = list(rows)
         row_indices = [r + count if r < 0 else r for r in row_indices]
@@ -47,27 +59,36 @@ def iloc(df, rows=None, cols=None, return_type='q'):
             target_cols = [all_cols[i] for i in range(*cols.indices(len(all_cols)))]
         else:
             target_cols = [all_cols[i] for i in cols]
-            
-    if row_indices is None and target_cols is None:
+
+    if not _use_sublist and row_indices is None and target_cols is None:
         return _handle_return(table, return_type)
 
-    if row_indices is not None and target_cols is not None:
+    # Fast path: contiguous row slice via q's sublist (no Python list overhead)
+    if _use_sublist:
+        sublist_args = kx.LongVector([_slice_start, _slice_count])
+        if target_cols is not None:
+            syms = kx.SymbolVector(target_cols)
+            cols_dict = kx.q('!', syms, syms)
+            q_res = kx.q('{?[sublist[y;x];();0b;z]}', table, sublist_args, cols_dict)
+        else:
+            q_res = kx.q('{sublist[y;x]}', table, sublist_args)
+    elif row_indices is not None and target_cols is not None:
         q_query = '{?[x y;();0b;z]}'
         syms = kx.SymbolVector(target_cols)
         cols_dict = kx.q('!', syms, syms)
         q_res = kx.q(q_query, table, kx.LongVector(row_indices), cols_dict)
-        
+
     elif row_indices is not None:
         q_query = '{x y}'
         q_res = kx.q(q_query, table, kx.LongVector(row_indices))
-        
+
     elif target_cols is not None:
         q_query = '{?[x;();0b;y]}'
         syms = kx.SymbolVector(target_cols)
         cols_dict = kx.q('!', syms, syms)
         q_res = kx.q(q_query, table, cols_dict)
-        
+
     else:
         q_res = table
 
-    return _handle_return(q_res, return_type)
+    return _handle_return(q_res, return_type)

{qutepandas-1.1.0 → qutepandas-1.1.1/qutePandas.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qutePandas
-Version: 1.1.0
+Version: 1.1.1
 Summary: A pandas-like library for kdb+/q using pykx
 Home-page: https://ishapatro.github.io/qutePandas/
 Author: Isha Patro

{qutepandas-1.1.0 → qutepandas-1.1.1}/qutePandas.egg-info/SOURCES.txt

@@ -39,4 +39,5 @@ qutePandas/transformation/__init__.py
 qutePandas/transformation/cast.py
 qutePandas/transformation/drop_col.py
 qutePandas/transformation/rename.py
+tests/test_pykx_setup.py
 tests/test_utils.py

{qutepandas-1.1.0 → qutepandas-1.1.1}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="qutePandas",
-    version="1.1.0",
+    version="1.1.1",
     packages=find_packages(),
     package_data={
         'qutePandas': ['*.q'],

qutepandas-1.1.1/tests/test_pykx_setup.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""
+PyKX + qutePandas Setup Verification Test
+
+This standalone test file verifies that:
+1. PyKX license is properly configured
+2. Embedded q initializes successfully
+3. qutePandas imports without errors
+4. Basic DataFrame operations work correctly
+
+Run this file to diagnose and verify your PyKX + qutePandas setup.
+"""
+
+import sys
+import os
+from pathlib import Path
+
+
+def print_section(title):
+    """Print a formatted section header."""
+    print(f"\n{'=' * 70}")
+    print(f"  {title}")
+    print('=' * 70)
+
+
+def print_result(test_name, passed, message=""):
+    """Print a test result with status indicator."""
+    status = "✅ PASS" if passed else "❌ FAIL"
+    print(f"{status}: {test_name}")
+    if message:
+        print(f"       {message}")
+
+
+def check_python_version():
+    """Verify Python version is 3.8 or higher."""
+    print_section("Python Version Check")
+    version = sys.version_info
+    print(f"Python version: {version.major}.{version.minor}.{version.micro}")
+    
+    if version.major >= 3 and version.minor >= 8:
+        print_result("Python Version", True, "Python 3.8+ detected")
+        return True
+    else:
+        print_result("Python Version", False, "Python 3.8+ required")
+        return False
+
+
+def check_license_files():
+    """Check for kdb+ license files in common locations."""
+    print_section("License File Detection")
+    
+    locations = [
+        Path.home() / ".qutepandas" / "kc.lic",
+        Path(__file__).parent.parent / "kdb_lic" / "kc.lic",
+        Path.home() / "kdb+" / "kc.lic",
+        Path.home() / "q" / "kc.lic",
+    ]
+    
+    found_licenses = []
+    for loc in locations:
+        if loc.exists():
+            found_licenses.append(str(loc))
+            print(f"  Found: {loc}")
+    
+    qlic = os.environ.get('QLIC')
+    kx_token = os.environ.get('KX_TOKEN') or os.environ.get('KDB_TOKEN')
+    pykx_unlicensed = os.environ.get('PYKX_UNLICENSED')
+    
+    print(f"\nEnvironment Variables:")
+    print(f"  QLIC: {qlic if qlic else 'Not set'}")
+    print(f"  KX_TOKEN: {'Set' if kx_token else 'Not set'}")
+    print(f"  PYKX_UNLICENSED: {pykx_unlicensed if pykx_unlicensed else 'Not set'}")
+    
+    if found_licenses or kx_token or pykx_unlicensed == 'true':
+        print_result("License Detection", True, 
+                    f"Found {len(found_licenses)} license file(s) or valid configuration")
+        return True
+    else:
+        print_result("License Detection", False, 
+                    "No license found - will attempt unlicensed mode")
+        return False
+
+
+def test_pykx_import():
+    """Test PyKX import and initialization."""
+    print_section("PyKX Import and Initialization")
+    
+    try:
+        import pykx as kx
+        print(f"PyKX version: {kx.__version__}")
+        print_result("PyKX Import", True)
+        return True, kx
+    except Exception as e:
+        print_result("PyKX Import", False, str(e))
+        return False, None
+
+
+def test_embedded_q(kx):
+    """Test embedded q functionality."""
+    print_section("Embedded Q Initialization")
+    
+    if kx is None:
+        print_result("Embedded Q", False, "PyKX not available")
+        return False
+    
+    try:
+        # Test basic q expression
+        result = kx.q('1+1')
+        expected = 2
+        
+        if result.py() == expected:
+            print_result("Basic Q Expression", True, f"1+1 = {result.py()}")
+        else:
+            print_result("Basic Q Expression", False, 
+                        f"Expected {expected}, got {result.py()}")
+            return False
+        
+        # Test table creation
+        table = kx.q('([] a:1 2 3; b:`x`y`z)')
+        print(f"Created q table:\n{table}")
+        print_result("Q Table Creation", True)
+        
+        return True
+    except Exception as e:
+        print_result("Embedded Q", False, str(e))
+        return False
+
+
+def test_qutepandas_import():
+    """Test qutePandas import."""
+    print_section("qutePandas Import")
+    
+    try:
+        import qutePandas as qpd
+        print(f"qutePandas version: {qpd.__version__}")
+        print_result("qutePandas Import", True)
+        return True, qpd
+    except Exception as e:
+        print_result("qutePandas Import", False, str(e))
+        print(f"\nFull error:\n{e}")
+        import traceback
+        traceback.print_exc()
+        return False, None
+
+
+def test_qutepandas_operations(qpd):
+    """Test basic qutePandas DataFrame operations."""
+    print_section("qutePandas DataFrame Operations")
+    
+    if qpd is None:
+        print_result("DataFrame Operations", False, "qutePandas not available")
+        return False
+    
+    try:
+        # Test 1: Create DataFrame from dict
+        df = qpd.DataFrame({
+            'id': [1, 2, 3, 4, 5],
+            'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
+            'score': [95.5, 87.3, 92.1, 78.9, 88.4]
+        })
+        print(f"Created DataFrame:\n{df}")
+        print_result("DataFrame Creation", True)
+        
+        # Test 2: Get dtypes
+        dtypes = qpd.dtypes(df)
+        print(f"\nDataFrame dtypes:\n{dtypes}")
+        print_result("Get Dtypes", True)
+        
+        # Test 3: Convert to pandas
+        pdf = df.pd()
+        print(f"\nConverted to pandas:\n{pdf}")
+        print_result("Convert to Pandas", True, f"Shape: {pdf.shape}")
+        
+        # Test 4: Filter operation
+        filtered = qpd.apply(df, lambda x: x['score'] > 85)
+        print(f"\nFiltered (score > 85):\n{filtered}")
+        print_result("Filter Operation", True)
+        
+        # Test 5: Groupby operation
+        df2 = qpd.DataFrame({
+            'category': ['A', 'B', 'A', 'B', 'A'],
+            'value': [10, 20, 30, 40, 50]
+        })
+        grouped = qpd.groupby_sum(df2, 'category', 'value')
+        print(f"\nGroupby sum:\n{grouped}")
+        print_result("Groupby Operation", True)
+        
+        return True
+    except Exception as e:
+        print_result("DataFrame Operations", False, str(e))
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def print_diagnostic_info():
+    """Print diagnostic information for troubleshooting."""
+    print_section("Diagnostic Information")
+    
+    import platform
+    print(f"OS: {platform.system()} {platform.release()}")
+    print(f"Architecture: {platform.machine()}")
+    print(f"Python: {sys.version}")
+    
+    print(f"\nEnvironment Variables:")
+    for var in ['QHOME', 'QLIC', 'PYKX_UNLICENSED', 'PYKX_RELEASE_GIL', 
+                'PYKX_ENFORCE_EMBEDDED_IMPORT', 'KX_TOKEN', 'KDB_TOKEN']:
+        value = os.environ.get(var, 'Not set')
+        print(f"  {var}: {value}")
+    
+    print(f"\nPython Path:")
+    for path in sys.path[:5]:
+        print(f"  {path}")
+
+
+def main():
+    """Run all tests."""
+    print("\n" + "=" * 70)
+    print("  PyKX + qutePandas Setup Verification")
+    print("=" * 70)
+    
+    results = []
+    
+    # Test 1: Python version
+    results.append(check_python_version())
+    
+    # Test 2: License detection
+    results.append(check_license_files())
+    
+    # Test 3: PyKX import
+    pykx_ok, kx = test_pykx_import()
+    results.append(pykx_ok)
+    
+    # Test 4: Embedded q
+    if pykx_ok:
+        results.append(test_embedded_q(kx))
+    else:
+        results.append(False)
+    
+    # Test 5: qutePandas import
+    qpd_ok, qpd = test_qutepandas_import()
+    results.append(qpd_ok)
+    
+    # Test 6: qutePandas operations
+    if qpd_ok:
+        results.append(test_qutepandas_operations(qpd))
+    else:
+        results.append(False)
+    
+    # Print diagnostic info
+    print_diagnostic_info()
+    
+    # Summary
+    print_section("Test Summary")
+    passed = sum(results)
+    total = len(results)
+    
+    print(f"\nTests Passed: {passed}/{total}")
+    
+    if passed == total:
+        print("\n🎉 SUCCESS! PyKX + qutePandas is properly configured.")
+        return 0
+    else:
+        print("\n⚠️  ISSUES DETECTED. See failures above for details.")
+        print("\nCommon solutions:")
+        print("  1. Ensure kc.lic is in ~/.qutepandas/ or project kdb_lic/")
+        print("  2. Set PYKX_UNLICENSED=true for unlicensed mode")
+        print("  3. Check that Python is 3.8+")
+        print("  4. Reinstall: pip install --upgrade pykx")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

qutepandas-1.1.0/qutePandas/cleaning/fillna.py

@@ -1,36 +0,0 @@
-import pykx as kx
-import pandas as pd
-from ..utils import _ensure_q_table, _handle_return
-
-def fillna(df, values, return_type='q'):
-    """
-    Fills null values using a dictionary mapping of columns to fill values.
-
-    Parameters
-    ----------
-    df : pandas.DataFrame or pykx.Table
-        Input DataFrame.
-    values : dict
-        Mapping of column names to fill values.
-    return_type : str, default 'q'
-        Desired return type ('p' or 'q').
-
-    Returns
-    -------
-    pandas.DataFrame or pykx.Table
-        DataFrame with nulls filled.
-    """
-    try:
-        if not isinstance(values, dict):
-            raise ValueError("values must be a dictionary")
-
-        q_table = _ensure_q_table(df)
-        result = q_table
-
-        for col, val in values.items():
-            fill_val = f'`{val}' if isinstance(val, str) else str(val)
-            result = kx.q(f"{{update {col}:{fill_val}^{col} from x}}", result)
-
-        return _handle_return(result, return_type)
-    except Exception as e:
-        raise RuntimeError(f"Failed to fillna: {e}")