tricoder 1.2.8__py3-none-any.whl

tricoder/typed_view.py

@@ -0,0 +1,313 @@
+"""Typed view: symbol × type-token matrix, PPMI, and SVD."""
+import re
+from multiprocessing import cpu_count
+from typing import Dict, Tuple, List
+
+import numpy as np
+from scipy import sparse
+from sklearn.decomposition import TruncatedSVD
+
+
+def _get_num_workers() -> int:
+    """Get number of workers (all cores - 1, minimum 1)."""
+    return max(1, cpu_count() - 1)
+
+
+def parse_composite_type(type_token: str) -> Tuple[List[str], List[str]]:
+    """
+    Parse composite type into constructor tokens and primitive tokens.
+    
+    Examples:
+        List[int] -> (['List'], ['int'])
+        Dict[str, int] -> (['Dict'], ['str', 'int'])
+        Optional[T] -> (['Optional'], ['T'])
+        List[Dict[str, int]] -> (['List', 'Dict'], ['str', 'int'])
+    
+    Args:
+        type_token: type token string
+    
+    Returns:
+        Tuple of (constructor_tokens, primitive_tokens)
+    """
+    constructors = []
+    primitives = []
+
+    # Extract generic type constructors (List, Dict, Optional, Set, Tuple, etc.)
+    # Pattern: ConstructorName[content]
+    generic_pattern = r'([A-Z][a-zA-Z0-9_]*)\s*\[([^\]]+)\]'
+
+    # Find all generic types
+    matches = list(re.finditer(generic_pattern, type_token))
+
+    if matches:
+        # Extract constructors
+        for match in matches:
+            constructor = match.group(1)
+            constructors.append(constructor)
+
+            # Recursively parse inner content
+            inner_content = match.group(2)
+            inner_constructors, inner_primitives = parse_composite_type(inner_content)
+            constructors.extend(inner_constructors)
+            primitives.extend(inner_primitives)
+
+        # Extract remaining primitives (not in generic brackets)
+        remaining = type_token
+        for match in reversed(matches):
+            remaining = remaining[:match.start()] + remaining[match.end():]
+
+        # Split by comma and extract primitives
+        for part in remaining.split(','):
+            part = part.strip()
+            if part and not re.match(r'^[A-Z][a-zA-Z0-9_]*\s*\[', part):
+                # Check if it's a primitive (lowercase or single letter)
+                if part[0].islower() or (len(part) == 1 and part.isalpha()):
+                    primitives.append(part)
+    else:
+        # No generic types, check if it's a primitive or simple type
+        parts = [p.strip() for p in type_token.split(',')]
+        for part in parts:
+            if part:
+                # If starts with uppercase and not a known primitive, treat as constructor
+                if part[0].isupper() and part not in ['int', 'str', 'float', 'bool', 'None']:
+                    constructors.append(part)
+                else:
+                    primitives.append(part)
+
+    return constructors, primitives
+
+
+def expand_type_semantics(node_types: Dict[int, Dict[str, int]],
+                          type_to_idx: Dict[str, int],
+                          num_nodes: int) -> Tuple[Dict[int, Dict[str, int]], Dict[str, int]]:
+    """
+    Expand type tokens into constructors and primitives.
+    
+    Args:
+        node_types: mapping from node_idx to {type_token: count}
+        type_to_idx: mapping from type token to index
+        num_nodes: number of nodes
+    
+    Returns:
+        Tuple of (expanded_node_types, expanded_type_to_idx)
+    """
+    expanded_node_types = {}
+    expanded_type_to_idx = dict(type_to_idx)
+
+    # Start with existing type indices
+    current_idx = len(expanded_type_to_idx)
+
+    # Process each node's types
+    for node_idx, types_dict in node_types.items():
+        expanded_types = dict(types_dict)  # Start with original types
+
+        for type_token, count in types_dict.items():
+            # Parse composite type
+            constructors, primitives = parse_composite_type(type_token)
+
+            # Add constructor tokens
+            for constructor in constructors:
+                if constructor not in expanded_type_to_idx:
+                    expanded_type_to_idx[constructor] = current_idx
+                    current_idx += 1
+
+                constructor_idx = expanded_type_to_idx[constructor]
+                expanded_types[constructor] = expanded_types.get(constructor, 0) + int(count * 0.5)
+
+            # Add primitive tokens
+            for primitive in primitives:
+                if primitive not in expanded_type_to_idx:
+                    expanded_type_to_idx[primitive] = current_idx
+                    current_idx += 1
+
+                primitive_idx = expanded_type_to_idx[primitive]
+                expanded_types[primitive] = expanded_types.get(primitive, 0) + int(count * 0.25)
+
+        expanded_node_types[node_idx] = expanded_types
+
+    return expanded_node_types, expanded_type_to_idx
+
+
+def build_type_matrix(node_types: Dict[int, Dict[str, int]],
+                      type_to_idx: Dict[str, int],
+                      num_nodes: int,
+                      expand_types: bool = True) -> Tuple[sparse.csr_matrix, Dict[str, int]]:
+    """
+    Build sparse symbol × type-token matrix with optional type expansion.
+    
+    Args:
+        node_types: mapping from node_idx to {type_token: count}
+        type_to_idx: mapping from type token to index
+        num_nodes: number of nodes (may include subtokens, but node_types only has original nodes)
+        expand_types: whether to expand composite types
+    
+    Returns:
+        Tuple of (type_matrix, final_type_to_idx)
+    """
+    final_node_types = node_types
+    final_type_to_idx = type_to_idx
+
+    if expand_types:
+        # Use original num_nodes (before subtokens) for expansion
+        original_num_nodes = max(node_types.keys()) + 1 if node_types else 0
+        final_node_types, final_type_to_idx = expand_type_semantics(
+            node_types, type_to_idx, original_num_nodes
+        )
+
+    num_types = len(final_type_to_idx)
+    rows = []
+    cols = []
+    data = []
+
+    for node_idx, types_dict in final_node_types.items():
+        for type_token, count in types_dict.items():
+            if type_token in final_type_to_idx:
+                type_idx = final_type_to_idx[type_token]
+                rows.append(node_idx)
+                cols.append(type_idx)
+                data.append(float(count))
+
+    # Pad matrix to num_nodes rows (subtokens will have zero rows)
+    type_matrix = sparse.csr_matrix((data, (rows, cols)), shape=(num_nodes, num_types))
+    return type_matrix, final_type_to_idx
+
+
+def compute_ppmi_types(type_matrix: sparse.csr_matrix, k: float = 1.0) -> sparse.csr_matrix:
+    """
+    Compute PPMI for type matrix.
+    
+    Args:
+        type_matrix: sparse symbol × type matrix
+        k: shift parameter
+    
+    Returns:
+        PPMI matrix (sparse)
+    """
+    cooc = type_matrix.copy()
+    cooc.data = np.maximum(cooc.data, 0)
+
+    # Compute marginals
+    row_sums = np.array(cooc.sum(axis=1)).flatten()
+    col_sums = np.array(cooc.sum(axis=0)).flatten()
+    total = float(cooc.sum())
+
+    # Ensure row_sums and col_sums match matrix dimensions exactly
+    if len(row_sums) != cooc.shape[0]:
+        # Create full-size array and fill with row_sums
+        full_row_sums = np.zeros(cooc.shape[0])
+        full_row_sums[:len(row_sums)] = row_sums
+        row_sums = full_row_sums
+    if len(col_sums) != cooc.shape[1]:
+        # Create full-size array and fill with col_sums
+        full_col_sums = np.zeros(cooc.shape[1])
+        full_col_sums[:len(col_sums)] = col_sums
+        col_sums = full_col_sums
+
+    # Avoid division by zero
+    row_sums = np.maximum(row_sums, 1e-10)
+    col_sums = np.maximum(col_sums, 1e-10)
+    total = max(total, 1e-10)
+
+    # Compute PMI
+    rows, cols = cooc.nonzero()
+    values = cooc.data
+
+    # Ensure indices are within bounds
+    rows = np.clip(rows, 0, len(row_sums) - 1).astype(int)
+    cols = np.clip(cols, 0, len(col_sums) - 1).astype(int)
+
+    # Ensure all arrays have the same length
+    min_len = min(len(values), len(rows), len(cols))
+    if min_len < len(values):
+        values = values[:min_len]
+        rows = rows[:min_len]
+        cols = cols[:min_len]
+
+    p_ij = values / total
+    p_i = row_sums[rows] / total
+    p_j = col_sums[cols] / total
+
+    # Ensure all have same shape
+    assert len(p_ij) == len(p_i) == len(
+        p_j), f"Shape mismatch: p_ij={len(p_ij)}, p_i={len(p_i)}, p_j={len(p_j)}"
+
+    pmi = np.log(p_ij / (p_i * p_j + 1e-10) + 1e-10)
+    ppmi = np.maximum(pmi, 0.0)
+
+    ppmi_matrix = sparse.csr_matrix((ppmi, (rows, cols)), shape=cooc.shape)
+    return ppmi_matrix
+
+
+def compute_typed_view(node_types: Dict[int, Dict[str, int]],
+                       type_to_idx: Dict[str, int],
+                       num_nodes: int,
+                       dim: int,
+                       random_state: int = 42,
+                       n_jobs: int = -1,
+                       expand_types: bool = True,
+                       gpu_accelerator=None) -> Tuple[np.ndarray, np.ndarray, Dict[str, int]]:
+    """
+    Compute typed view embeddings with optional type expansion.
+    
+    Returns:
+        embeddings: node embeddings from typed view
+        svd_components: SVD components for reconstruction
+        final_type_to_idx: expanded type token mapping
+    """
+    type_matrix, final_type_to_idx = build_type_matrix(
+        node_types, type_to_idx, num_nodes, expand_types=expand_types
+    )
+    ppmi = compute_ppmi_types(type_matrix)
+    embeddings, svd_components = reduce_dimensions_ppmi(ppmi, dim, random_state, n_jobs, gpu_accelerator)
+    return embeddings, svd_components, final_type_to_idx
+
+
+def reduce_dimensions_ppmi(ppmi: sparse.csr_matrix, dim: int, random_state: int = 42,
+                           n_jobs: int = -1, gpu_accelerator=None) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Reduce PPMI matrix dimensionality using Truncated SVD (GPU-accelerated if available).
+    
+    Args:
+        ppmi: PPMI matrix
+        dim: target dimensionality
+        random_state: random seed
+        n_jobs: number of parallel jobs (not used, kept for API consistency)
+        gpu_accelerator: Optional GPUAccelerator instance for GPU acceleration
+    
+    Returns:
+        Reduced embeddings matrix and SVD components
+    """
+    num_features = ppmi.shape[1]
+    actual_dim = min(dim, num_features)
+
+    # Try GPU acceleration if available
+    if gpu_accelerator and gpu_accelerator.use_gpu:
+        try:
+            # Convert sparse matrix to dense for GPU SVD
+            if ppmi.shape[0] * ppmi.shape[1] < 50_000_000:  # ~50M elements threshold
+                ppmi_dense = ppmi.toarray()
+                U, S, Vt = gpu_accelerator.svd(ppmi_dense, actual_dim, random_state)
+                embeddings = U @ np.diag(S)
+                components = Vt
+            else:
+                raise ValueError("Matrix too large for GPU dense SVD")
+        except Exception:
+            # Fall back to CPU
+            svd = TruncatedSVD(n_components=actual_dim, random_state=random_state, n_iter=5)
+            embeddings = svd.fit_transform(ppmi)
+            components = svd.components_
+    else:
+        # CPU path
+        svd = TruncatedSVD(n_components=actual_dim, random_state=random_state, n_iter=5)
+        embeddings = svd.fit_transform(ppmi)
+        components = svd.components_
+
+    # Pad embeddings if needed to match requested dimension
+    if actual_dim < dim:
+        padding = np.zeros((embeddings.shape[0], dim - actual_dim))
+        embeddings = np.hstack([embeddings, padding])
+        # Pad components similarly
+        component_padding = np.zeros((dim - actual_dim, components.shape[1]))
+        components = np.vstack([components, component_padding])
+
+    return embeddings, components

tricoder-1.2.8.dist-info/METADATA

@@ -0,0 +1,306 @@
+Metadata-Version: 2.4
+Name: tricoder
+Version: 1.2.8
+Summary: TriVector Code Intelligence - Multi-view code relationship model with advanced semantic embeddings
+License: Non-Commercial
+License-File: LICENSE
+License-File: LICENSE_COMMERCIAL.md
+Keywords: code-intelligence,embeddings,semantic-analysis,code-search
+Author: Jiri Otoupal
+Author-email: j.f.otoupal@gmail.com
+Requires-Python: >=3.8.1,<4.0.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: annoy (>=1.17.0)
+Requires-Dist: click (>=8.0.0)
+Requires-Dist: gensim (>=4.0.0)
+Requires-Dist: numpy (>=1.21.0)
+Requires-Dist: rich (>=13.0.0)
+Requires-Dist: scikit-learn (>=1.0.0)
+Requires-Dist: scipy (>=1.7.0)
+Project-URL: Homepage, https://github.com/jiri-otoupal/tricoder
+Project-URL: Repository, https://github.com/jiri-otoupal/tricoder
+Description-Content-Type: text/markdown
+
+# TriVector Embeddings for Smarter Code Search for AI Agents
+
+[![image](https://img.shields.io/pypi/v/tricoder.svg)](https://pypi.org/project/tricoder/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/tricoder)](https://pypi.org/project/tricoder/)
+
+[![Build Status](https://travis-ci.com/jiri-otoupal/pycrosskit.svg?branch=master)](https://travis-ci.com/github/jiri-otoupal/tricoder)
+[![Downloads](https://pepy.tech/badge/tricoder)](https://pepy.tech/project/tricoder)
+
+## TriCoder learns high-quality symbol-level embeddings from codebases using three complementary views:
+
+1. **Graph View**: Structural relationships via PPMI and SVD
+2. **Context View**: Semantic context via Node2Vec random walks and Word2Vec
+3. **Typed View**: Type information via type-token co-occurrence (optional)
+
+## Features
+
+- **Subtoken Semantic Graph**: Captures fine-grained semantic relationships through subtoken analysis
+- **File & Module Hierarchy**: Leverages file/directory structure for better clustering
+- **Static Call-Graph Expansion**: Propagates call relationships to depth 2-3
+- **Type Semantic Expansion**: Expands composite types into constructors and primitives
+- **Context Window Co-occurrence**: Captures lexical context within ±5 lines
+- **Improved Negative Sampling**: Biased sampling for better temperature calibration
+- **Hybrid Similarity Scoring**: Length-penalized cosine similarity
+- **Iterative Embedding Smoothing**: Diffusion-based smoothing for better clustering
+- **Query-Time Semantic Expansion**: Expands queries with subtokens and types
+- **GPU Acceleration**: Supports CUDA (NVIDIA) and MPS (Mac) for faster training
+- **Keyword Search**: Search symbols by keywords and type tokens
+- **Graph Optimization**: Filter out low-value nodes and edges to improve training efficiency
+
+## Installation
+
+### Using Poetry (Recommended)
+
+```bash
+poetry install
+```
+
+### Using pip
+
+```bash
+pip install .
+```
+
+### GPU Support (Optional)
+
+For NVIDIA GPUs (CUDA):
+```bash
+pip install cupy-cuda12x
+```
+
+For Mac GPUs (MPS):
+```bash
+pip install torch
+```
+
+## Usage
+
+### 1. Extract Symbols from Codebase
+
+```bash
+# Basic extraction (Python files only)
+tricoder extract --input-dir /path/to/codebase
+
+# Extract specific file types
+tricoder extract --input-dir /path/to/codebase --extensions "py,js,ts"
+
+# Exclude specific keywords from extraction
+tricoder extract --input-dir /path/to/codebase --exclude-keywords debug --exclude-keywords temp
+
+# Custom output files
+tricoder extract --input-dir /path/to/codebase --output-nodes my_nodes.jsonl --output-edges my_edges.jsonl
+```
+
+**Extraction Options:**
+- `--input-dir`, `--root`, `-r`: Input directory to scan (default: current directory)
+- `--extensions`, `--ext`: Comma-separated file extensions (default: `py`)
+- `--include-dirs`, `-i`: Include only specific subdirectories (can specify multiple)
+- `--exclude-dirs`, `-e`: Exclude directories (default: `.venv`, `__pycache__`, `.git`, `node_modules`, `.pytest_cache`)
+- `--exclude-keywords`, `--exclude`: Exclude symbol names (appended to default excluded keywords)
+- `--output-nodes`, `-n`: Output file for nodes (default: `nodes.jsonl`)
+- `--output-edges`, `-d`: Output file for edges (default: `edges.jsonl`)
+- `--output-types`, `-t`: Output file for types (default: `types.jsonl`)
+- `--no-gitignore`: Disable `.gitignore` filtering (enabled by default)
+
+### 2. Optimize Graph (Optional)
+
+Reduce graph size by filtering low-value nodes and edges:
+
+```bash
+# Basic optimization (overwrites input files)
+tricoder optimize
+
+# Custom output files
+tricoder optimize --output-nodes nodes_opt.jsonl --output-edges edges_opt.jsonl
+
+# Customize thresholds
+tricoder optimize --min-edge-weight 0.5 --remove-isolated --remove-generic
+
+# Keep isolated nodes
+tricoder optimize --keep-isolated
+```
+
+**Optimization Options:**
+- `--nodes`, `-n`: Input nodes file (default: `nodes.jsonl`)
+- `--edges`, `-e`: Input edges file (default: `edges.jsonl`)
+- `--types`, `-t`: Input types file (default: `types.jsonl`, optional)
+- `--output-nodes`, `-N`: Output nodes file (default: overwrites input)
+- `--output-edges`, `-E`: Output edges file (default: overwrites input)
+- `--output-types`, `-T`: Output types file (default: overwrites input)
+- `--min-edge-weight`: Minimum edge weight to keep (default: `0.3`)
+- `--remove-isolated`: Remove nodes with no edges (default: `True`)
+- `--keep-isolated`: Keep isolated nodes (overrides `--remove-isolated`)
+- `--remove-generic`: Remove generic names (default: `True`)
+- `--keep-generic`: Keep generic names (overrides `--remove-generic`)
+- `--exclude-keywords`, `--exclude`: Additional keywords to exclude (can specify multiple)
+
+### 3. Train Model
+
+```bash
+# Basic training
+tricoder train --out model_output
+
+# With GPU acceleration
+tricoder train --out model_output --use-gpu
+
+# Fast mode (faster training, slightly lower quality)
+tricoder train --out model_output --fast
+
+# Custom dimensions
+tricoder train --out model_output --graph-dim 128 --context-dim 128 --final-dim 256
+
+# Custom training parameters
+tricoder train --out model_output --num-walks 20 --walk-length 100 --train-ratio 0.9
+```
+
+**Training Options:**
+- `--nodes`, `-n`: Path to nodes.jsonl (default: `nodes.jsonl`)
+- `--edges`, `-e`: Path to edges.jsonl (default: `edges.jsonl`)
+- `--types`, `-t`: Path to types.jsonl (default: `types.jsonl`, optional)
+- `--out`, `-o`: Output directory (required)
+- `--graph-dim`: Graph view dimensionality (default: auto-calculated)
+- `--context-dim`: Context view dimensionality (default: auto-calculated)
+- `--typed-dim`: Typed view dimensionality (default: auto-calculated)
+- `--final-dim`: Final fused embedding dimensionality (default: auto-calculated)
+- `--num-walks`: Number of random walks per node (default: `10`)
+- `--walk-length`: Length of each random walk (default: `80`)
+- `--train-ratio`: Fraction of edges for training (default: `0.8`)
+- `--random-state`: Random seed for reproducibility (default: `42`)
+- `--fast`: Enable fast mode (reduces parameters for faster training)
+- `--use-gpu`: Enable GPU acceleration (CUDA or MPS, falls back to CPU if unavailable)
+
+### 4. Query Model
+
+```bash
+# Query by symbol ID
+tricoder query --model-dir model_output --symbol function_my_function_0001 --top-k 10
+
+# Search by keywords
+tricoder query --model-dir model_output --keywords "database connection" --top-k 10
+
+# Multi-word phrases (use quotes)
+tricoder query --model-dir model_output --keywords '"user authentication" login'
+
+# Exclude specific keywords from results
+tricoder query --model-dir model_output --keywords handler --exclude-keywords debug --exclude-keywords temp
+
+# Interactive mode
+tricoder query --model-dir model_output --interactive
+```
+
+**Query Options:**
+- `--model-dir`, `-m`: Path to model directory (required)
+- `--symbol`, `-s`: Symbol ID to query
+- `--keywords`, `-w`: Keywords to search for (use quotes for multi-word: `"my function"`)
+- `--top-k`, `-k`: Number of results to return (default: `10`)
+- `--exclude-keywords`, `--exclude`: Additional keywords to exclude (appended to default excluded keywords)
+- `--interactive`, `-i`: Interactive mode
+
+### 5. Incremental Retraining
+
+Retrain only on changed files since last training:
+
+```bash
+# Basic retraining (detects changed files automatically)
+tricoder retrain --model-dir model_output --codebase-dir /path/to/codebase
+
+# Force full retraining
+tricoder retrain --model-dir model_output --codebase-dir /path/to/codebase --force
+
+# Custom training parameters
+tricoder retrain --model-dir model_output --codebase-dir /path/to/codebase --num-walks 20
+```
+
+**Retrain Options:**
+- `--model-dir`, `-m`: Path to existing model directory (required)
+- `--codebase-dir`, `-c`: Path to codebase root (default: current directory)
+- `--output-nodes`, `-n`: Temporary nodes file (default: `nodes_retrain.jsonl`)
+- `--output-edges`, `-d`: Temporary edges file (default: `edges_retrain.jsonl`)
+- `--output-types`, `-t`: Temporary types file (default: `types_retrain.jsonl`)
+- `--graph-dim`, `--context-dim`, `--typed-dim`, `--final-dim`: Override model dimensions
+- `--num-walks`, `--walk-length`, `--train-ratio`, `--random-state`: Training parameters
+- `--force`: Force full retraining even if no files changed
+
+## Examples
+
+### Complete Workflow
+
+```bash
+# 1. Extract symbols from codebase
+tricoder extract --input-dir ./my_project --extensions "py,js"
+
+# 2. (Optional) Optimize the graph
+tricoder optimize --min-edge-weight 0.4
+
+# 3. Train model with GPU acceleration
+tricoder train --out ./models/my_project --use-gpu
+
+# 4. Query for similar symbols
+tricoder query --model-dir ./models/my_project --keywords "database" --top-k 5
+
+# 5. After code changes, retrain incrementally
+tricoder retrain --model-dir ./models/my_project --codebase-dir ./my_project
+```
+
+### Keyword Search Examples
+
+```bash
+# Search for authentication-related code
+tricoder query --model-dir model_output --keywords "auth login password"
+
+# Search for specific function name
+tricoder query --model-dir model_output --keywords '"process_payment"'
+
+# Search excluding common keywords
+tricoder query --model-dir model_output --keywords handler --exclude-keywords temp --exclude-keywords debug
+```
+
+## Requirements
+
+- Python 3.8+
+- numpy >= 1.21.0
+- scipy >= 1.7.0
+- scikit-learn >= 1.0.0
+- gensim >= 4.0.0
+- annoy >= 1.17.0
+- click >= 8.0.0
+- rich >= 13.0.0
+
+**Optional (for GPU acceleration):**
+- cupy-cuda12x >= 12.0.0 (for NVIDIA GPUs)
+- torch >= 2.0.0 (for Mac GPUs or CUDA fallback)
+
+## License
+
+TriCoder is available under a **Non-Commercial License**.
+
+- ✅ **Free for non-commercial use**: Personal projects, education, research, open-source
+- ❌ **Commercial license required**: Paid products, SaaS, commercial consulting, enterprise use
+
+For commercial licensing inquiries, please contact: **j.f.otoupal@gmail.com**
+
+See [LICENSE](LICENSE) for full terms and [LICENSE_COMMERCIAL.md](LICENSE_COMMERCIAL.md) for commercial license information.
+
+<hr>
+Did I made your life less painfull ? 
+<br>
+<br>
+Support my coffee addiction ;)
+<br>
+<a href="https://www.buymeacoffee.com/jiriotoupal" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy me a Coffee" style="height: 41px !important;width: 174px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>
+

tricoder-1.2.8.dist-info/RECORD

@@ -0,0 +1,22 @@
+tricoder/__about__.py,sha256=zxNuFkE-43tg4N6VDTNwDHbnUa7Paps028DvLJzUIQ8,212
+tricoder/__init__.py,sha256=oBD9XnaSedZoC_9IjO03vBpU4edMRaQu06_82qPe1cg,625
+tricoder/calibration.py,sha256=i19uCm_pWk0F3YCx8YrpakadKNe4o7pe9XflBaoc-0M,9887
+tricoder/cli.py,sha256=FqsSv6H_Woz1GBwAZHZSxOJ4DUsn3en6rR2W89lkwI8,41548
+tricoder/context_view.py,sha256=RuGliktScT_qVGXsrMKipEX3vFV__FBEM347PKb6zKk,8052
+tricoder/data_loader.py,sha256=oktaQLz8rGtim9NcOB_Ewi14B4HVpAbmhOrqrgoBsPw,5044
+tricoder/extract.py,sha256=G1iSNMz00N1keYl1HYHjNIYjrE8XWZmkrm4TMNUGecg,23777
+tricoder/fusion.py,sha256=2TDuoKJ2CTyN4potX6XW2KTTmkiEA0ARQYiQeRj3ujY,7605
+tricoder/git_tracker.py,sha256=bKRt2gGWSR7BzPkDZvvNjQf8XrREOeBQgZjSH-15hcg,7155
+tricoder/gpu_utils.py,sha256=QfaKefQ2HDTDSxUMOi9jKgik9_q-N1WjjLTV5_v7tqo,16126
+tricoder/graph_view.py,sha256=YZAPhUajSvRw52WdsTSYoBkED9cKLpC-L8mPEoT8IqE,22227
+tricoder/model.py,sha256=2FZl1C9UPriFkH_iMEqbGeOMONEq4gcURrU9-oUhUXw,20459
+tricoder/optimize.py,sha256=FgbWLL-x0q5fV5US8r_2nllfazbU6-aohCXB3hPt_uM,8765
+tricoder/subtoken_utils.py,sha256=Z7eHH6pjWmG-sJ9VsTJeoL11l6AmGk3kM9VI0WzAzJM,5833
+tricoder/train.py,sha256=cmj_y3P_htJkGi_2G2z7VhX63k8xO90jeDjQZSPqoS0,41948
+tricoder/typed_view.py,sha256=MzC-QAgY_nahXx_BEk_YMjPMxZj_t43NKSHkQweQ4lY,11580
+tricoder-1.2.8.dist-info/METADATA,sha256=uW2jd2-ELFqqtMguJ2Stl84B5s7LSJFSzr4NsZpW6JE,11883
+tricoder-1.2.8.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+tricoder-1.2.8.dist-info/entry_points.txt,sha256=luwxM7BzbfdWNJvwRYVUhm3z5bDF3ZoK0M5lzGajgZs,45
+tricoder-1.2.8.dist-info/licenses/LICENSE,sha256=POHObqU-qPg7DWoG6PVphyxu187YFhlhVp_MEBldcF8,2526
+tricoder-1.2.8.dist-info/licenses/LICENSE_COMMERCIAL.md,sha256=Omn6tI3kUiuBMvcrXhJw2sEH_WHjzaImgDIra-WyRik,2472
+tricoder-1.2.8.dist-info/RECORD,,

tricoder-1.2.8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

tricoder-1.2.8.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+tricoder=tricoder.cli:cli
+