liaozhaorun/ProStock
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(factorminer): 统一模块引用路径并移除独立包配置

Browse Source 
- 批量替换 60+ 个文件中的 factorminer 导入为 src.factorminer.factorminer.*
- 删除子项目独立的 .gitignore、pyproject.toml、uv.lock
- 新增本地框架整合实施计划文档
This commit is contained in:
liaozhaorun
2026-04-07 22:19:02 +08:00
parent dadf8da145
commit a51701e2da
71 changed files with 276 additions and 4030 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/factorminer/.gitignore vendored
View File

@@ -1,12 +0,0 @@
.env
.venv/
__pycache__/
*.py[cod]
.pytest_cache/
.mypy_cache/
.ruff_cache/
.coverage
htmlcov/
build/
dist/
*.egg-info/

2
src/factorminer/factorminer/__init__.py
View File

@@ -3,7 +3,7 @@
__version__ = "0.1.0" __version__ = "0.1.0"
__author__ = "FactorMiner Team" __author__ = "FactorMiner Team"
from factorminer.utils.config import ( from src.factorminer.factorminer.utils.config import (
Config, Config,
MiningConfig, MiningConfig,
EvaluationConfig, EvaluationConfig,

14
src/factorminer/factorminer/agent/__init__.py
View File

@@ -1,7 +1,7 @@
"""LLM agent integration for factor generation.""" """LLM agent integration for factor generation."""
from factorminer.agent.factor_generator import FactorGenerator from src.factorminer.factorminer.agent.factor_generator import FactorGenerator
from factorminer.agent.llm_interface import ( from src.factorminer.factorminer.agent.llm_interface import (
AnthropicProvider, AnthropicProvider,
GoogleProvider, GoogleProvider,
LLMProvider, LLMProvider,
@@ -9,14 +9,14 @@ from factorminer.agent.llm_interface import (
OpenAIProvider, OpenAIProvider,
create_provider, create_provider,
) )
from factorminer.agent.output_parser import CandidateFactor, parse_llm_output from src.factorminer.factorminer.agent.output_parser import CandidateFactor, parse_llm_output
from factorminer.agent.prompt_builder import ( from src.factorminer.factorminer.agent.prompt_builder import (
PromptBuilder, PromptBuilder,
build_critic_scoring_prompt, build_critic_scoring_prompt,
build_debate_synthesis_prompt, build_debate_synthesis_prompt,
build_specialist_prompt, build_specialist_prompt,
) )
from factorminer.agent.specialists import ( from src.factorminer.factorminer.agent.specialists import (
DEFAULT_SPECIALISTS, DEFAULT_SPECIALISTS,
LIQUIDITY_SPECIALIST, LIQUIDITY_SPECIALIST,
MOMENTUM_SPECIALIST, MOMENTUM_SPECIALIST,
@@ -28,8 +28,8 @@ from factorminer.agent.specialists import (
SpecialistDomainMemory, SpecialistDomainMemory,
SpecialistPromptBuilder, SpecialistPromptBuilder,
) )
from factorminer.agent.critic import CriticAgent, CriticScore from src.factorminer.factorminer.agent.critic import CriticAgent, CriticScore
from factorminer.agent.debate import ( from src.factorminer.factorminer.agent.debate import (
DebateConfig, DebateConfig,
DebateGenerator, DebateGenerator,
DebateMemory, DebateMemory,

6
src/factorminer/factorminer/agent/critic.py
View File

@@ -22,9 +22,9 @@ from collections import Counter
from dataclasses import dataclass, field from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Set, Tuple from typing import Any, Dict, List, Optional, Set, Tuple
from factorminer.agent.llm_interface import LLMProvider from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from factorminer.agent.output_parser import CandidateFactor from src.factorminer.factorminer.agent.output_parser import CandidateFactor
from factorminer.agent.prompt_builder import normalize_factor_references from src.factorminer.factorminer.agent.prompt_builder import normalize_factor_references
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)

12
src/factorminer/factorminer/agent/debate.py
View File

@@ -21,15 +21,15 @@ from collections import Counter
from dataclasses import dataclass, field from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional from typing import Any, Dict, List, Optional
from factorminer.agent.critic import CriticAgent, CriticScore from src.factorminer.factorminer.agent.critic import CriticAgent, CriticScore
from factorminer.agent.factor_generator import FactorGenerator from src.factorminer.factorminer.agent.factor_generator import FactorGenerator
from factorminer.agent.llm_interface import LLMProvider from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from factorminer.agent.output_parser import CandidateFactor from src.factorminer.factorminer.agent.output_parser import CandidateFactor
from factorminer.agent.prompt_builder import ( from src.factorminer.factorminer.agent.prompt_builder import (
PromptBuilder, PromptBuilder,
normalize_factor_references, normalize_factor_references,
) )
from factorminer.agent.specialists import ( from src.factorminer.factorminer.agent.specialists import (
DEFAULT_SPECIALISTS, DEFAULT_SPECIALISTS,
SpecialistAgent, SpecialistAgent,
SpecialistConfig, SpecialistConfig,

6
src/factorminer/factorminer/agent/factor_generator.py
View File

@@ -10,9 +10,9 @@ import logging
import time import time
from typing import Any, Dict, List, Optional from typing import Any, Dict, List, Optional
from factorminer.agent.llm_interface import LLMProvider from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from factorminer.agent.output_parser import CandidateFactor, parse_llm_output from src.factorminer.factorminer.agent.output_parser import CandidateFactor, parse_llm_output
from factorminer.agent.prompt_builder import PromptBuilder from src.factorminer.factorminer.agent.prompt_builder import PromptBuilder
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)

6
src/factorminer/factorminer/agent/output_parser.py
View File

@@ -12,9 +12,9 @@ import re
from dataclasses import dataclass, field from dataclasses import dataclass, field
from typing import Dict, List, Optional, Tuple from typing import Dict, List, Optional, Tuple
from factorminer.core.expression_tree import ExpressionTree from src.factorminer.factorminer.core.expression_tree import ExpressionTree
from factorminer.core.parser import parse, try_parse from src.factorminer.factorminer.core.parser import parse, try_parse
from factorminer.core.types import OperatorType, OPERATOR_REGISTRY from src.factorminer.factorminer.core.types import OperatorType, OPERATOR_REGISTRY
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)

2
src/factorminer/factorminer/agent/prompt_builder.py
View File

@@ -9,7 +9,7 @@ from __future__ import annotations
from typing import Any, Dict, List, Optional from typing import Any, Dict, List, Optional
from factorminer.core.types import ( from src.factorminer.factorminer.core.types import (
FEATURES, FEATURES,
OPERATOR_REGISTRY, OPERATOR_REGISTRY,
OperatorSpec, OperatorSpec,

6
src/factorminer/factorminer/agent/specialists.py
View File

@@ -13,9 +13,9 @@ import logging
from dataclasses import dataclass, field from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional from typing import Any, Dict, List, Optional
from factorminer.agent.llm_interface import LLMProvider from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from factorminer.agent.output_parser import CandidateFactor, parse_llm_output from src.factorminer.factorminer.agent.output_parser import CandidateFactor, parse_llm_output
from factorminer.agent.prompt_builder import ( from src.factorminer.factorminer.agent.prompt_builder import (
SYSTEM_PROMPT, SYSTEM_PROMPT,
PromptBuilder, PromptBuilder,
normalize_factor_references, normalize_factor_references,

4
src/factorminer/factorminer/benchmark/__init__.py
View File

@@ -1,6 +1,6 @@
"""Benchmark runners for paper-faithful and Helix research evaluation.""" """Benchmark runners for paper-faithful and Helix research evaluation."""
from factorminer.benchmark.runtime import ( from src.factorminer.factorminer.benchmark.runtime import (
BenchmarkManifest, BenchmarkManifest,
build_benchmark_library, build_benchmark_library,
evaluate_frozen_set, evaluate_frozen_set,
@@ -13,7 +13,7 @@ from factorminer.benchmark.runtime import (
run_table1_benchmark, run_table1_benchmark,
select_frozen_top_k, select_frozen_top_k,
) )
from factorminer.benchmark.helix_benchmark import ( from src.factorminer.factorminer.benchmark.helix_benchmark import (
HelixBenchmark, HelixBenchmark,
BenchmarkResult, BenchmarkResult,
MethodResult, MethodResult,

30
src/factorminer/factorminer/benchmark/ablation.py
View File

@@ -29,31 +29,31 @@ from typing import Any, Dict, List, Optional, Tuple
import numpy as np import numpy as np
import pandas as pd import pandas as pd
import factorminer.core.helix_loop as helix_loop_module import src.factorminer.factorminer.core.helix_loop as helix_loop_module
import factorminer.core.ralph_loop as ralph_loop_module import src.factorminer.factorminer.core.ralph_loop as ralph_loop_module
from factorminer.agent.debate import DebateConfig as RuntimeDebateConfig from src.factorminer.factorminer.agent.debate import DebateConfig as RuntimeDebateConfig
from factorminer.agent.llm_interface import MockProvider from src.factorminer.factorminer.agent.llm_interface import MockProvider
from factorminer.benchmark.helix_benchmark import AblationResult, MethodResult from src.factorminer.factorminer.benchmark.helix_benchmark import AblationResult, MethodResult
from factorminer.core.config import MiningConfig from src.factorminer.factorminer.core.config import MiningConfig
from factorminer.core.helix_loop import HelixLoop from src.factorminer.factorminer.core.helix_loop import HelixLoop
from factorminer.core.factor_library import FactorLibrary from src.factorminer.factorminer.core.factor_library import FactorLibrary
from factorminer.evaluation.capacity import CapacityConfig as RuntimeCapacityConfig from src.factorminer.factorminer.evaluation.capacity import CapacityConfig as RuntimeCapacityConfig
from factorminer.evaluation.causal import CausalConfig as RuntimeCausalConfig from src.factorminer.factorminer.evaluation.causal import CausalConfig as RuntimeCausalConfig
from factorminer.evaluation.regime import RegimeConfig as RuntimeRegimeConfig from src.factorminer.factorminer.evaluation.regime import RegimeConfig as RuntimeRegimeConfig
from factorminer.evaluation.runtime import ( from src.factorminer.factorminer.evaluation.runtime import (
DatasetSplit, DatasetSplit,
EvaluationDataset, EvaluationDataset,
evaluate_factors, evaluate_factors,
) )
from factorminer.evaluation.significance import ( from src.factorminer.factorminer.evaluation.significance import (
SignificanceConfig as RuntimeSignificanceConfig, SignificanceConfig as RuntimeSignificanceConfig,
) )
from factorminer.benchmark.runtime import ( from src.factorminer.factorminer.benchmark.runtime import (
build_benchmark_library, build_benchmark_library,
evaluate_frozen_set, evaluate_frozen_set,
select_frozen_top_k, select_frozen_top_k,
) )
from factorminer.memory.memory_store import ExperienceMemory from src.factorminer.factorminer.memory.memory_store import ExperienceMemory
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)

2
src/factorminer/factorminer/benchmark/catalogs.py
View File

@@ -8,7 +8,7 @@ from typing import Iterable
import numpy as np import numpy as np
from factorminer.core.library_io import PAPER_FACTORS from src.factorminer.factorminer.core.library_io import PAPER_FACTORS
@dataclass(frozen=True) @dataclass(frozen=True)

8
src/factorminer/factorminer/benchmark/helix_benchmark.py
View File

@@ -1095,12 +1095,12 @@ class HelixBenchmark:
# factorminer.agent.specialists.REGIME_SPECIALIST in some environments. # factorminer.agent.specialists.REGIME_SPECIALIST in some environments.
import importlib.util as _ilu, pathlib as _pl, sys as _sys import importlib.util as _ilu, pathlib as _pl, sys as _sys
_cat_path = _pl.Path(__file__).parent / "catalogs.py" _cat_path = _pl.Path(__file__).parent / "catalogs.py"
if "factorminer.benchmark.catalogs" not in _sys.modules: if "src.factorminer.factorminer.benchmark.catalogs" not in _sys.modules:
_spec = _ilu.spec_from_file_location("factorminer.benchmark.catalogs", str(_cat_path)) _spec = _ilu.spec_from_file_location("src.factorminer.factorminer.benchmark.catalogs", str(_cat_path))
_cat_mod = _ilu.module_from_spec(_spec) _cat_mod = _ilu.module_from_spec(_spec)
_sys.modules["factorminer.benchmark.catalogs"] = _cat_mod _sys.modules["src.factorminer.factorminer.benchmark.catalogs"] = _cat_mod
_spec.loader.exec_module(_cat_mod) _spec.loader.exec_module(_cat_mod)
_cat = _sys.modules["factorminer.benchmark.catalogs"] _cat = _sys.modules["src.factorminer.factorminer.benchmark.catalogs"]
ALPHA101_CLASSIC = _cat.ALPHA101_CLASSIC ALPHA101_CLASSIC = _cat.ALPHA101_CLASSIC
build_alpha101_adapted = _cat.build_alpha101_adapted build_alpha101_adapted = _cat.build_alpha101_adapted
build_random_exploration = _cat.build_random_exploration build_random_exploration = _cat.build_random_exploration

10
src/factorminer/factorminer/benchmark/runtime.py
View File

@@ -15,7 +15,7 @@ from typing import Any, Iterable, Optional
import numpy as np import numpy as np
import pandas as pd import pandas as pd
from factorminer.benchmark.catalogs import ( from src.factorminer.factorminer.benchmark.catalogs import (
CandidateEntry, CandidateEntry,
build_alpha101_adapted, build_alpha101_adapted,
build_alphaagent_style, build_alphaagent_style,
@@ -27,10 +27,10 @@ from factorminer.benchmark.catalogs import (
entries_from_library, entries_from_library,
ALPHA101_CLASSIC, ALPHA101_CLASSIC,
) )
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import load_library from src.factorminer.factorminer.core.library_io import load_library
from factorminer.core.session import MiningSession from src.factorminer.factorminer.core.session import MiningSession
from factorminer.evaluation.runtime import ( from src.factorminer.factorminer.evaluation.runtime import (
EvaluationDataset, EvaluationDataset,
FactorEvaluationArtifact, FactorEvaluationArtifact,
compute_correlation_matrix, compute_correlation_matrix,

2
src/factorminer/factorminer/cli.py
View File

@@ -11,7 +11,7 @@ from pathlib import Path
import click import click
import numpy as np import numpy as np
from factorminer.utils.config import load_config from src.factorminer.factorminer.utils.config import load_config
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)

20
src/factorminer/factorminer/core/__init__.py
View File

@@ -1,26 +1,26 @@
"""FactorMiner core: expression trees, types, factor DSL parser, and Ralph Loop.""" """FactorMiner core: expression trees, types, factor DSL parser, and Ralph Loop."""
from factorminer.core.expression_tree import ( from src.factorminer.factorminer.core.expression_tree import (
ConstantNode, ConstantNode,
ExpressionTree, ExpressionTree,
LeafNode, LeafNode,
Node, Node,
OperatorNode, OperatorNode,
) )
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import ( from src.factorminer.factorminer.core.library_io import (
export_csv, export_csv,
export_formulas, export_formulas,
import_from_paper, import_from_paper,
load_library, load_library,
save_library, save_library,
) )
from factorminer.core.parser import parse, try_parse from src.factorminer.factorminer.core.parser import parse, try_parse
from factorminer.core.ralph_loop import RalphLoop from src.factorminer.factorminer.core.ralph_loop import RalphLoop
from factorminer.core.helix_loop import HelixLoop from src.factorminer.factorminer.core.helix_loop import HelixLoop
from factorminer.core.session import MiningSession from src.factorminer.factorminer.core.session import MiningSession
from factorminer.core.config import MiningConfig as CoreMiningConfig from src.factorminer.factorminer.core.config import MiningConfig as CoreMiningConfig
from factorminer.core.types import ( from src.factorminer.factorminer.core.types import (
FEATURES, FEATURES,
FEATURE_SET, FEATURE_SET,
OPERATOR_REGISTRY, OPERATOR_REGISTRY,
@@ -29,7 +29,7 @@ from factorminer.core.types import (
SignatureType, SignatureType,
get_operator, get_operator,
) )
from factorminer.core.canonicalizer import FormulaCanonicalizer from src.factorminer.factorminer.core.canonicalizer import FormulaCanonicalizer
__all__ = [ __all__ = [
# Expression tree # Expression tree

2
src/factorminer/factorminer/core/canonicalizer.py
View File

@@ -21,7 +21,7 @@ from typing import Dict, List, Optional
import sympy import sympy
from sympy import Abs, Float, Function, Symbol, log, sqrt from sympy import Abs, Float, Function, Symbol, log, sqrt
from factorminer.core.expression_tree import ( from src.factorminer.factorminer.core.expression_tree import (
ConstantNode, ConstantNode,
ExpressionTree, ExpressionTree,
LeafNode, LeafNode,

2
src/factorminer/factorminer/core/expression_tree.py
View File

@@ -14,7 +14,7 @@ from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
import numpy as np import numpy as np
from factorminer.core.types import ( from src.factorminer.factorminer.core.types import (
FEATURE_SET, FEATURE_SET,
OperatorSpec, OperatorSpec,
OperatorType, OperatorType,

20
src/factorminer/factorminer/core/helix_loop.py
View File

@@ -22,22 +22,22 @@ from typing import Any, Dict, List, Optional, Set, Tuple
import numpy as np import numpy as np
from factorminer.core.ralph_loop import ( from src.factorminer.factorminer.core.ralph_loop import (
BudgetTracker, BudgetTracker,
EvaluationResult, EvaluationResult,
FactorGenerator, FactorGenerator,
RalphLoop, RalphLoop,
ValidationPipeline, ValidationPipeline,
) )
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.parser import try_parse from src.factorminer.factorminer.core.parser import try_parse
from factorminer.evaluation.metrics import compute_ic from src.factorminer.factorminer.evaluation.metrics import compute_ic
from factorminer.memory.memory_store import ExperienceMemory from src.factorminer.factorminer.memory.memory_store import ExperienceMemory
from factorminer.memory.retrieval import retrieve_memory from src.factorminer.factorminer.memory.retrieval import retrieve_memory
from factorminer.memory.formation import form_memory from src.factorminer.factorminer.memory.formation import form_memory
from factorminer.memory.evolution import evolve_memory from src.factorminer.factorminer.memory.evolution import evolve_memory
from factorminer.agent.llm_interface import LLMProvider from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from factorminer.utils.logging import IterationRecord, FactorRecord from src.factorminer.factorminer.utils.logging import IterationRecord, FactorRecord
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)

2
src/factorminer/factorminer/core/library_io.py
View File

@@ -14,7 +14,7 @@ from typing import Dict, List, Optional, Union
import numpy as np import numpy as np
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)

4
src/factorminer/factorminer/core/parser.py
View File

@@ -34,14 +34,14 @@ from dataclasses import dataclass
from enum import Enum, auto from enum import Enum, auto
from typing import Dict, List, Optional, Tuple from typing import Dict, List, Optional, Tuple
from factorminer.core.expression_tree import ( from src.factorminer.factorminer.core.expression_tree import (
ConstantNode, ConstantNode,
ExpressionTree, ExpressionTree,
LeafNode, LeafNode,
Node, Node,
OperatorNode, OperatorNode,
) )
from factorminer.core.types import FEATURE_SET, OPERATOR_REGISTRY, OperatorSpec from src.factorminer.factorminer.core.types import FEATURE_SET, OPERATOR_REGISTRY, OperatorSpec
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

34
src/factorminer/factorminer/core/ralph_loop.py
View File

@@ -30,33 +30,33 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
import numpy as np import numpy as np
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import save_library, load_library from src.factorminer.factorminer.core.library_io import save_library, load_library
from factorminer.core.provenance import build_factor_provenance, build_run_manifest from src.factorminer.factorminer.core.provenance import build_factor_provenance, build_run_manifest
from factorminer.core.parser import try_parse from src.factorminer.factorminer.core.parser import try_parse
from factorminer.core.session import MiningSession from src.factorminer.factorminer.core.session import MiningSession
from factorminer.core.types import FEATURES from src.factorminer.factorminer.core.types import FEATURES
from factorminer.memory.experience_memory import ExperienceMemoryManager from src.factorminer.factorminer.memory.experience_memory import ExperienceMemoryManager
from factorminer.memory.memory_store import ExperienceMemory from src.factorminer.factorminer.memory.memory_store import ExperienceMemory
from factorminer.memory.retrieval import retrieve_memory from src.factorminer.factorminer.memory.retrieval import retrieve_memory
from factorminer.memory.formation import form_memory from src.factorminer.factorminer.memory.formation import form_memory
from factorminer.memory.evolution import evolve_memory from src.factorminer.factorminer.memory.evolution import evolve_memory
from factorminer.agent.llm_interface import LLMProvider, MockProvider from src.factorminer.factorminer.agent.llm_interface import LLMProvider, MockProvider
from factorminer.agent.prompt_builder import PromptBuilder from src.factorminer.factorminer.agent.prompt_builder import PromptBuilder
from factorminer.evaluation.metrics import ( from src.factorminer.factorminer.evaluation.metrics import (
compute_factor_stats, compute_factor_stats,
compute_ic, compute_ic,
compute_ic_mean, compute_ic_mean,
compute_ic_win_rate, compute_ic_win_rate,
compute_icir, compute_icir,
) )
from factorminer.evaluation.research import ( from src.factorminer.factorminer.evaluation.research import (
build_score_vector, build_score_vector,
compute_factor_geometry, compute_factor_geometry,
passes_research_admission, passes_research_admission,
) )
from factorminer.evaluation.runtime import SignalComputationError, compute_tree_signals from src.factorminer.factorminer.evaluation.runtime import SignalComputationError, compute_tree_signals
from factorminer.utils.logging import ( from src.factorminer.factorminer.utils.logging import (
IterationRecord, IterationRecord,
FactorRecord, FactorRecord,
MiningSessionLogger, MiningSessionLogger,

8
src/factorminer/factorminer/data/__init__.py
View File

@@ -1,18 +1,18 @@
"""FactorMiner data pipeline: loading, preprocessing, and tensor construction.""" """FactorMiner data pipeline: loading, preprocessing, and tensor construction."""
from factorminer.data.loader import ( from src.factorminer.factorminer.data.loader import (
OHLCV_COLUMNS, OHLCV_COLUMNS,
REQUIRED_COLUMNS, REQUIRED_COLUMNS,
load_market_data, load_market_data,
load_multiple, load_multiple,
to_numpy, to_numpy,
) )
from factorminer.data.mock_data import ( from src.factorminer.factorminer.data.mock_data import (
MockConfig, MockConfig,
generate_mock_data, generate_mock_data,
generate_with_halts, generate_with_halts,
) )
from factorminer.data.preprocessor import ( from src.factorminer.factorminer.data.preprocessor import (
PreprocessConfig, PreprocessConfig,
compute_derived_features, compute_derived_features,
compute_returns, compute_returns,
@@ -25,7 +25,7 @@ from factorminer.data.preprocessor import (
quality_check, quality_check,
winsorise, winsorise,
) )
from factorminer.data.tensor_builder import ( from src.factorminer.factorminer.data.tensor_builder import (
DEFAULT_FEATURES, DEFAULT_FEATURES,
TargetSpec, TargetSpec,
TensorConfig, TensorConfig,

26
src/factorminer/factorminer/evaluation/__init__.py
View File

@@ -1,18 +1,18 @@
"""Multi-stage factor evaluation and validation pipeline.""" """Multi-stage factor evaluation and validation pipeline."""
from factorminer.evaluation.admission import ( from src.factorminer.factorminer.evaluation.admission import (
AdmissionDecision, AdmissionDecision,
StockThresholds, StockThresholds,
check_admission, check_admission,
check_replacement, check_replacement,
) )
from factorminer.evaluation.correlation import ( from src.factorminer.factorminer.evaluation.correlation import (
IncrementalCorrelationMatrix, IncrementalCorrelationMatrix,
batch_spearman_correlation, batch_spearman_correlation,
batch_spearman_pairwise, batch_spearman_pairwise,
compute_correlation_batch, compute_correlation_batch,
) )
from factorminer.evaluation.metrics import ( from src.factorminer.factorminer.evaluation.metrics import (
compute_factor_stats, compute_factor_stats,
compute_ic, compute_ic,
compute_ic_mean, compute_ic_mean,
@@ -23,7 +23,7 @@ from factorminer.evaluation.metrics import (
compute_quintile_returns, compute_quintile_returns,
compute_turnover, compute_turnover,
) )
from factorminer.evaluation.pipeline import ( from src.factorminer.factorminer.evaluation.pipeline import (
CandidateFactor, CandidateFactor,
EvaluationResult, EvaluationResult,
FactorLibraryView, FactorLibraryView,
@@ -31,10 +31,10 @@ from factorminer.evaluation.pipeline import (
ValidationPipeline, ValidationPipeline,
run_evaluation_pipeline, run_evaluation_pipeline,
) )
from factorminer.evaluation.combination import FactorCombiner from src.factorminer.factorminer.evaluation.combination import FactorCombiner
from factorminer.evaluation.selection import FactorSelector from src.factorminer.factorminer.evaluation.selection import FactorSelector
from factorminer.evaluation.portfolio import PortfolioBacktester from src.factorminer.factorminer.evaluation.portfolio import PortfolioBacktester
from factorminer.evaluation.backtest import ( from src.factorminer.factorminer.evaluation.backtest import (
SplitWindow, SplitWindow,
DrawdownResult, DrawdownResult,
train_test_split, train_test_split,
@@ -48,7 +48,7 @@ from factorminer.evaluation.backtest import (
compute_sharpe_ratio, compute_sharpe_ratio,
compute_calmar_ratio, compute_calmar_ratio,
) )
from factorminer.evaluation.regime import ( from src.factorminer.factorminer.evaluation.regime import (
MarketRegime, MarketRegime,
RegimeConfig, RegimeConfig,
RegimeClassification, RegimeClassification,
@@ -56,7 +56,7 @@ from factorminer.evaluation.regime import (
RegimeICResult, RegimeICResult,
RegimeAwareEvaluator, RegimeAwareEvaluator,
) )
from factorminer.evaluation.capacity import ( from src.factorminer.factorminer.evaluation.capacity import (
CapacityConfig, CapacityConfig,
CapacityEstimate, CapacityEstimate,
CapacityEstimator, CapacityEstimator,
@@ -64,12 +64,12 @@ from factorminer.evaluation.capacity import (
MarketImpactModel, MarketImpactModel,
NetCostResult, NetCostResult,
) )
from factorminer.evaluation.causal import ( from src.factorminer.factorminer.evaluation.causal import (
CausalConfig, CausalConfig,
CausalTestResult, CausalTestResult,
CausalValidator, CausalValidator,
) )
from factorminer.evaluation.significance import ( from src.factorminer.factorminer.evaluation.significance import (
BootstrapCIResult, BootstrapCIResult,
BootstrapICTester, BootstrapICTester,
DeflatedSharpeCalculator, DeflatedSharpeCalculator,
@@ -79,7 +79,7 @@ from factorminer.evaluation.significance import (
SignificanceConfig, SignificanceConfig,
check_significance, check_significance,
) )
from factorminer.evaluation.research import ( from src.factorminer.factorminer.evaluation.research import (
FactorGeometryDiagnostics, FactorGeometryDiagnostics,
FactorScoreVector, FactorScoreVector,
build_score_vector, build_score_vector,

2
src/factorminer/factorminer/evaluation/capacity.py
View File

@@ -12,7 +12,7 @@ from typing import Dict, List, Optional
import numpy as np import numpy as np
from factorminer.evaluation.metrics import compute_ic, compute_icir from src.factorminer.factorminer.evaluation.metrics import compute_ic, compute_icir
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

2
src/factorminer/factorminer/evaluation/causal.py
View File

@@ -22,7 +22,7 @@ from typing import Any, Dict, List, Optional, Tuple
import numpy as np import numpy as np
from factorminer.evaluation.metrics import compute_ic from src.factorminer.factorminer.evaluation.metrics import compute_ic
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)

6
src/factorminer/factorminer/evaluation/pipeline.py
View File

@@ -23,17 +23,17 @@ from typing import Any, Callable, Dict, List, Optional, Tuple
import numpy as np import numpy as np
from factorminer.evaluation.admission import ( from src.factorminer.factorminer.evaluation.admission import (
AdmissionDecision, AdmissionDecision,
check_admission, check_admission,
check_replacement, check_replacement,
) )
from factorminer.evaluation.correlation import ( from src.factorminer.factorminer.evaluation.correlation import (
batch_spearman_correlation, batch_spearman_correlation,
batch_spearman_pairwise, batch_spearman_pairwise,
compute_correlation_batch, compute_correlation_batch,
) )
from factorminer.evaluation.metrics import ( from src.factorminer.factorminer.evaluation.metrics import (
compute_factor_stats, compute_factor_stats,
compute_ic, compute_ic,
compute_ic_mean, compute_ic_mean,

12
src/factorminer/factorminer/evaluation/research.py
View File

@@ -7,12 +7,12 @@ from typing import Dict, Iterable, Sequence
import numpy as np import numpy as np
from factorminer.evaluation.backtest import rolling_splits from src.factorminer.factorminer.evaluation.backtest import rolling_splits
from factorminer.evaluation.metrics import compute_factor_stats, compute_pairwise_correlation from src.factorminer.factorminer.evaluation.metrics import compute_factor_stats, compute_pairwise_correlation
from factorminer.evaluation.portfolio import PortfolioBacktester from src.factorminer.factorminer.evaluation.portfolio import PortfolioBacktester
from factorminer.evaluation.regime import RegimeAwareEvaluator, RegimeConfig, RegimeDetector from src.factorminer.factorminer.evaluation.regime import RegimeAwareEvaluator, RegimeConfig, RegimeDetector
from factorminer.evaluation.selection import FactorSelector from src.factorminer.factorminer.evaluation.selection import FactorSelector
from factorminer.evaluation.significance import BootstrapICTester, SignificanceConfig from src.factorminer.factorminer.evaluation.significance import BootstrapICTester, SignificanceConfig
@dataclass @dataclass

8
src/factorminer/factorminer/evaluation/runtime.py
View File

@@ -10,10 +10,10 @@ from typing import Dict, Iterable, List, Optional, Sequence
import numpy as np import numpy as np
import pandas as pd import pandas as pd
from factorminer.core.factor_library import Factor from src.factorminer.factorminer.core.factor_library import Factor
from factorminer.core.parser import try_parse from src.factorminer.factorminer.core.parser import try_parse
from factorminer.data.tensor_builder import TargetSpec, compute_targets from src.factorminer.factorminer.data.tensor_builder import TargetSpec, compute_targets
from factorminer.evaluation.metrics import ( from src.factorminer.factorminer.evaluation.metrics import (
compute_factor_stats, compute_factor_stats,
compute_pairwise_correlation, compute_pairwise_correlation,
) )

10
src/factorminer/factorminer/memory/__init__.py
View File

@@ -11,17 +11,17 @@ Phase 2 additions:
- Enhanced Retrieval: KG + embedding augmented retrieval - Enhanced Retrieval: KG + embedding augmented retrieval
""" """
from factorminer.memory.memory_store import ( from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory, ExperienceMemory,
ForbiddenDirection, ForbiddenDirection,
MiningState, MiningState,
StrategicInsight, StrategicInsight,
SuccessPattern, SuccessPattern,
) )
from factorminer.memory.formation import form_memory from src.factorminer.factorminer.memory.formation import form_memory
from factorminer.memory.evolution import evolve_memory from src.factorminer.factorminer.memory.evolution import evolve_memory
from factorminer.memory.retrieval import retrieve_memory from src.factorminer.factorminer.memory.retrieval import retrieve_memory
from factorminer.memory.experience_memory import ExperienceMemoryManager from src.factorminer.factorminer.memory.experience_memory import ExperienceMemoryManager
# Phase 2: Optional imports (graceful if dependencies missing) # Phase 2: Optional imports (graceful if dependencies missing)
try: try:

2
src/factorminer/factorminer/memory/evolution.py
View File

@@ -11,7 +11,7 @@ from __future__ import annotations
from typing import Dict, List, Optional from typing import Dict, List, Optional
from factorminer.memory.memory_store import ( from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory, ExperienceMemory,
ForbiddenDirection, ForbiddenDirection,
MiningState, MiningState,

8
src/factorminer/factorminer/memory/experience_memory.py
View File

@@ -15,16 +15,16 @@ import logging
from pathlib import Path from pathlib import Path
from typing import Any, Dict, List, Optional from typing import Any, Dict, List, Optional
from factorminer.memory.memory_store import ( from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory, ExperienceMemory,
ForbiddenDirection, ForbiddenDirection,
MiningState, MiningState,
StrategicInsight, StrategicInsight,
SuccessPattern, SuccessPattern,
) )
from factorminer.memory.formation import form_memory from src.factorminer.factorminer.memory.formation import form_memory
from factorminer.memory.evolution import evolve_memory from src.factorminer.factorminer.memory.evolution import evolve_memory
from factorminer.memory.retrieval import retrieve_memory from src.factorminer.factorminer.memory.retrieval import retrieve_memory
# Optional Phase 2 imports # Optional Phase 2 imports
try: try:

2
src/factorminer/factorminer/memory/formation.py
View File

@@ -13,7 +13,7 @@ import re
from collections import Counter, defaultdict from collections import Counter, defaultdict
from typing import Any, Dict, List, Optional, Tuple from typing import Any, Dict, List, Optional, Tuple
from factorminer.memory.memory_store import ( from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory, ExperienceMemory,
ForbiddenDirection, ForbiddenDirection,
MiningState, MiningState,

4
src/factorminer/factorminer/memory/kg_retrieval.py
View File

@@ -4,8 +4,8 @@ from __future__ import annotations
from typing import Any, Dict, List, Optional, Set, Tuple from typing import Any, Dict, List, Optional, Set, Tuple
from factorminer.memory.memory_store import ExperienceMemory from src.factorminer.factorminer.memory.memory_store import ExperienceMemory
from factorminer.memory.retrieval import retrieve_memory from src.factorminer.factorminer.memory.retrieval import retrieve_memory
# Optional imports -- presence checked at call time # Optional imports -- presence checked at call time
try: try:

8
src/factorminer/factorminer/memory/online_regime_memory.py
View File

@@ -42,18 +42,18 @@ from typing import Any, Dict, FrozenSet, List, Optional, Tuple
import numpy as np import numpy as np
from factorminer.evaluation.regime import RegimeState, StreamingRegimeDetector, StreamingRegimeConfig from src.factorminer.factorminer.evaluation.regime import RegimeState, StreamingRegimeDetector, StreamingRegimeConfig
from factorminer.memory.memory_store import ( from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory, ExperienceMemory,
StrategicInsight, StrategicInsight,
SuccessPattern, SuccessPattern,
) )
from factorminer.memory.evolution import ( from src.factorminer.factorminer.memory.evolution import (
apply_confidence_decay, apply_confidence_decay,
bump_pattern_confidence, bump_pattern_confidence,
penalise_pattern_confidence, penalise_pattern_confidence,
) )
from factorminer.memory.retrieval import retrieve_memory from src.factorminer.factorminer.memory.retrieval import retrieve_memory
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)

2
src/factorminer/factorminer/memory/retrieval.py
View File

@@ -11,7 +11,7 @@ from __future__ import annotations
from typing import Any, Dict, List, Optional from typing import Any, Dict, List, Optional
from factorminer.memory.memory_store import ( from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory, ExperienceMemory,
ForbiddenDirection, ForbiddenDirection,
MiningState, MiningState,

8
src/factorminer/factorminer/operators/__init__.py
View File

@@ -3,7 +3,7 @@
Exports the central registry and all operator category modules. Exports the central registry and all operator category modules.
""" """
from factorminer.operators.registry import ( from src.factorminer.factorminer.operators.registry import (
OPERATOR_REGISTRY, OPERATOR_REGISTRY,
execute_operator, execute_operator,
get_impl, get_impl,
@@ -11,7 +11,7 @@ from factorminer.operators.registry import (
implemented_operators, implemented_operators,
list_operators, list_operators,
) )
from factorminer.operators.gpu_backend import ( from src.factorminer.factorminer.operators.gpu_backend import (
DeviceManager, DeviceManager,
batch_execute, batch_execute,
device_manager, device_manager,
@@ -19,12 +19,12 @@ from factorminer.operators.gpu_backend import (
to_tensor, to_tensor,
torch_available, torch_available,
) )
from factorminer.operators.auto_inventor import ( from src.factorminer.factorminer.operators.auto_inventor import (
OperatorInventor, OperatorInventor,
ProposedOperator, ProposedOperator,
ValidationResult, ValidationResult,
) )
from factorminer.operators.custom import ( from src.factorminer.factorminer.operators.custom import (
CustomOperator, CustomOperator,
CustomOperatorStore, CustomOperatorStore,
) )

4
src/factorminer/factorminer/operators/auto_inventor.py
View File

@@ -15,8 +15,8 @@ from typing import Any, Callable, Dict, List, Optional, Tuple
import numpy as np import numpy as np
from factorminer.agent.llm_interface import LLMProvider from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from factorminer.core.types import OPERATOR_REGISTRY, OperatorSpec from src.factorminer.factorminer.core.types import OPERATOR_REGISTRY, OperatorSpec
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)

4
src/factorminer/factorminer/operators/custom.py
View File

@@ -16,13 +16,13 @@ from typing import Any, Callable, Dict, List, Optional, Tuple
import numpy as np import numpy as np
from factorminer.core.types import ( from src.factorminer.factorminer.core.types import (
OPERATOR_REGISTRY as SPEC_REGISTRY, OPERATOR_REGISTRY as SPEC_REGISTRY,
OperatorSpec, OperatorSpec,
OperatorType, OperatorType,
SignatureType, SignatureType,
) )
from factorminer.operators.registry import OPERATOR_REGISTRY as RUNTIME_REGISTRY from src.factorminer.factorminer.operators.registry import OPERATOR_REGISTRY as RUNTIME_REGISTRY
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)

18
src/factorminer/factorminer/operators/registry.py
View File

@@ -10,16 +10,16 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
import numpy as np import numpy as np
from factorminer.core.types import OPERATOR_REGISTRY as SPEC_REGISTRY from src.factorminer.factorminer.core.types import OPERATOR_REGISTRY as SPEC_REGISTRY
from factorminer.core.types import OperatorSpec, OperatorType from src.factorminer.factorminer.core.types import OperatorSpec, OperatorType
from factorminer.operators.arithmetic import ARITHMETIC_OPS from src.factorminer.factorminer.operators.arithmetic import ARITHMETIC_OPS
from factorminer.operators.statistical import STATISTICAL_OPS from src.factorminer.factorminer.operators.statistical import STATISTICAL_OPS
from factorminer.operators.timeseries import TIMESERIES_OPS from src.factorminer.factorminer.operators.timeseries import TIMESERIES_OPS
from factorminer.operators.crosssectional import CROSSSECTIONAL_OPS from src.factorminer.factorminer.operators.crosssectional import CROSSSECTIONAL_OPS
from factorminer.operators.smoothing import SMOOTHING_OPS from src.factorminer.factorminer.operators.smoothing import SMOOTHING_OPS
from factorminer.operators.regression import REGRESSION_OPS from src.factorminer.factorminer.operators.regression import REGRESSION_OPS
from factorminer.operators.logical import LOGICAL_OPS from src.factorminer.factorminer.operators.logical import LOGICAL_OPS
try: try:
import torch import torch

4
src/factorminer/factorminer/tests/conftest.py
View File

@@ -5,8 +5,8 @@ from __future__ import annotations
import numpy as np import numpy as np
import pytest import pytest
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.memory.experience_memory import ExperienceMemoryManager from src.factorminer.factorminer.memory.experience_memory import ExperienceMemoryManager
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

4
src/factorminer/factorminer/tests/test_auto_inventor.py
View File

@@ -5,12 +5,12 @@ from __future__ import annotations
import numpy as np import numpy as np
import pytest import pytest
from factorminer.operators.auto_inventor import ( from src.factorminer.factorminer.operators.auto_inventor import (
OperatorInventor, OperatorInventor,
ProposedOperator, ProposedOperator,
_BLOCKED_TOKENS, _BLOCKED_TOKENS,
) )
from factorminer.operators.custom import CustomOperatorStore from src.factorminer.factorminer.operators.custom import CustomOperatorStore
# ----------------------------------------------------------------------- # -----------------------------------------------------------------------

42
src/factorminer/factorminer/tests/test_benchmark.py
View File

@@ -8,18 +8,18 @@ from types import SimpleNamespace
from click.testing import CliRunner from click.testing import CliRunner
import numpy as np import numpy as np
from factorminer.benchmark.runtime import ( from src.factorminer.factorminer.benchmark.runtime import (
build_benchmark_library, build_benchmark_library,
run_table1_benchmark, run_table1_benchmark,
select_frozen_top_k, select_frozen_top_k,
) )
from factorminer.benchmark.helix_benchmark import StatisticalComparisonTests, _json_safe from src.factorminer.factorminer.benchmark.helix_benchmark import StatisticalComparisonTests, _json_safe
from factorminer.cli import main from src.factorminer.factorminer.cli import main
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import save_library from src.factorminer.factorminer.core.library_io import save_library
from factorminer.core.session import MiningSession from src.factorminer.factorminer.core.session import MiningSession
from factorminer.evaluation.runtime import FactorEvaluationArtifact from src.factorminer.factorminer.evaluation.runtime import FactorEvaluationArtifact
from factorminer.utils.config import load_config from src.factorminer.factorminer.utils.config import load_config
from run_phase2_benchmark import ( from run_phase2_benchmark import (
_build_phase2_manifest, _build_phase2_manifest,
_collect_runtime_manifest_refs, _collect_runtime_manifest_refs,
@@ -127,7 +127,7 @@ def test_benchmark_table1_cli_invokes_runtime(monkeypatch, tmp_path):
} }
} }
monkeypatch.setattr("factorminer.benchmark.runtime.run_table1_benchmark", _fake_run) monkeypatch.setattr("src.factorminer.factorminer.benchmark.runtime.run_table1_benchmark", _fake_run)
runner = CliRunner() runner = CliRunner()
result = runner.invoke( result = runner.invoke(
@@ -193,15 +193,15 @@ def test_table1_manifest_includes_saved_library_provenance(monkeypatch, tmp_path
artifact = _artifact(1, "Neg($close)", 0.07, 0.8, 1.0) artifact = _artifact(1, "Neg($close)", 0.07, 0.8, 1.0)
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.benchmark.runtime.load_benchmark_dataset", "src.factorminer.factorminer.benchmark.runtime.load_benchmark_dataset",
lambda *args, **kwargs: (SimpleNamespace(), "freeze-hash"), lambda *args, **kwargs: (SimpleNamespace(), "freeze-hash"),
) )
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.benchmark.runtime.evaluate_factors", "src.factorminer.factorminer.benchmark.runtime.evaluate_factors",
lambda *args, **kwargs: [artifact], lambda *args, **kwargs: [artifact],
) )
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.benchmark.runtime.evaluate_frozen_set", "src.factorminer.factorminer.benchmark.runtime.evaluate_frozen_set",
lambda frozen, dataset, **kwargs: { lambda frozen, dataset, **kwargs: {
"factor_count": len(frozen), "factor_count": len(frozen),
"library": {"ic": 0.1, "icir": 1.0, "avg_abs_rho": 0.2}, "library": {"ic": 0.1, "icir": 1.0, "avg_abs_rho": 0.2},
@@ -402,19 +402,19 @@ def test_table1_runtime_methods_instantiate_live_loops(monkeypatch, tmp_path):
calls = [] calls = []
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.benchmark.runtime.load_benchmark_dataset", "src.factorminer.factorminer.benchmark.runtime.load_benchmark_dataset",
lambda *args, **kwargs: (_runtime_dataset_stub(), "dataset-hash"), lambda *args, **kwargs: (_runtime_dataset_stub(), "dataset-hash"),
) )
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.benchmark.runtime._get_baseline_entries", "src.factorminer.factorminer.benchmark.runtime._get_baseline_entries",
lambda *args, **kwargs: (_ for _ in ()).throw(AssertionError("catalog fallback used")), lambda *args, **kwargs: (_ for _ in ()).throw(AssertionError("catalog fallback used")),
) )
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.benchmark.runtime.evaluate_factors", "src.factorminer.factorminer.benchmark.runtime.evaluate_factors",
lambda *args, **kwargs: [_artifact(1, "Neg($close)", 0.08, 0.9, 1.0)], lambda *args, **kwargs: [_artifact(1, "Neg($close)", 0.08, 0.9, 1.0)],
) )
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.benchmark.runtime.evaluate_frozen_set", "src.factorminer.factorminer.benchmark.runtime.evaluate_frozen_set",
lambda frozen, dataset, **kwargs: { lambda frozen, dataset, **kwargs: {
"factor_count": len(frozen), "factor_count": len(frozen),
"library": {"ic": 0.1, "icir": 1.0, "avg_abs_rho": 0.2}, "library": {"ic": 0.1, "icir": 1.0, "avg_abs_rho": 0.2},
@@ -434,8 +434,8 @@ def test_table1_runtime_methods_instantiate_live_loops(monkeypatch, tmp_path):
calls.append("helix") calls.append("helix")
return _single_factor_library() return _single_factor_library()
monkeypatch.setattr("factorminer.core.ralph_loop.RalphLoop.run", _fake_ralph_run) monkeypatch.setattr("src.factorminer.factorminer.core.ralph_loop.RalphLoop.run", _fake_ralph_run)
monkeypatch.setattr("factorminer.core.helix_loop.HelixLoop.run", _fake_helix_run) monkeypatch.setattr("src.factorminer.factorminer.core.helix_loop.HelixLoop.run", _fake_helix_run)
payload = run_table1_benchmark( payload = run_table1_benchmark(
cfg, cfg,
@@ -455,7 +455,7 @@ def test_table1_runtime_methods_fail_loudly_without_catalog_fallback(monkeypatch
fallback_called = {"value": False} fallback_called = {"value": False}
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.benchmark.runtime.load_benchmark_dataset", "src.factorminer.factorminer.benchmark.runtime.load_benchmark_dataset",
lambda *args, **kwargs: (_runtime_dataset_stub(), "dataset-hash"), lambda *args, **kwargs: (_runtime_dataset_stub(), "dataset-hash"),
) )
@@ -463,9 +463,9 @@ def test_table1_runtime_methods_fail_loudly_without_catalog_fallback(monkeypatch
fallback_called["value"] = True fallback_called["value"] = True
raise AssertionError("catalog fallback used") raise AssertionError("catalog fallback used")
monkeypatch.setattr("factorminer.benchmark.runtime._get_baseline_entries", _forbidden_catalog) monkeypatch.setattr("src.factorminer.factorminer.benchmark.runtime._get_baseline_entries", _forbidden_catalog)
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.benchmark.runtime._run_runtime_mining_loop", "src.factorminer.factorminer.benchmark.runtime._run_runtime_mining_loop",
lambda *args, **kwargs: (_ for _ in ()).throw(RuntimeError("runtime loop failed")), lambda *args, **kwargs: (_ for _ in ()).throw(RuntimeError("runtime loop failed")),
) )

4
src/factorminer/factorminer/tests/test_canonicalizer.py
View File

@@ -6,8 +6,8 @@ import time
import pytest import pytest
from factorminer.core.canonicalizer import FormulaCanonicalizer from src.factorminer.factorminer.core.canonicalizer import FormulaCanonicalizer
from factorminer.core.parser import parse from src.factorminer.factorminer.core.parser import parse
@pytest.fixture @pytest.fixture

2
src/factorminer/factorminer/tests/test_capacity.py
View File

@@ -5,7 +5,7 @@ from __future__ import annotations
import numpy as np import numpy as np
import pytest import pytest
from factorminer.evaluation.capacity import ( from src.factorminer.factorminer.evaluation.capacity import (
CapacityConfig, CapacityConfig,
CapacityEstimator, CapacityEstimator,
MarketImpactModel, MarketImpactModel,

2
src/factorminer/factorminer/tests/test_causal.py
View File

@@ -5,7 +5,7 @@ from __future__ import annotations
import numpy as np import numpy as np
import pytest import pytest
from factorminer.evaluation.causal import CausalConfig, CausalTestResult, CausalValidator from src.factorminer.factorminer.evaluation.causal import CausalConfig, CausalTestResult, CausalValidator
@pytest.fixture @pytest.fixture

28
src/factorminer/factorminer/tests/test_cli_analysis.py
View File

@@ -7,10 +7,10 @@ from dataclasses import dataclass
from click.testing import CliRunner from click.testing import CliRunner
import numpy as np import numpy as np
from factorminer.cli import main from src.factorminer.factorminer.cli import main
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import save_library from src.factorminer.factorminer.core.library_io import save_library
from factorminer.evaluation.runtime import DatasetSplit, FactorEvaluationArtifact from src.factorminer.factorminer.evaluation.runtime import DatasetSplit, FactorEvaluationArtifact
@dataclass @dataclass
@@ -160,11 +160,11 @@ def test_evaluate_recomputes_and_selects_top_k_by_train_split(tmp_path, monkeypa
] ]
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.cli._load_runtime_dataset_for_analysis", "src.factorminer.factorminer.cli._load_runtime_dataset_for_analysis",
lambda cfg, data_path, mock: dataset, lambda cfg, data_path, mock: dataset,
) )
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.cli._recompute_analysis_artifacts", "src.factorminer.factorminer.cli._recompute_analysis_artifacts",
lambda library, dataset_arg, signal_failure_policy: artifacts, lambda library, dataset_arg, signal_failure_policy: artifacts,
) )
@@ -205,11 +205,11 @@ def test_combine_uses_fit_split_for_factor_preselection(tmp_path, monkeypatch):
captured_factor_ids: list[int] = [] captured_factor_ids: list[int] = []
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.cli._load_runtime_dataset_for_analysis", "src.factorminer.factorminer.cli._load_runtime_dataset_for_analysis",
lambda cfg, data_path, mock: dataset, lambda cfg, data_path, mock: dataset,
) )
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.cli._recompute_analysis_artifacts", "src.factorminer.factorminer.cli._recompute_analysis_artifacts",
lambda library, dataset_arg, signal_failure_policy: artifacts, lambda library, dataset_arg, signal_failure_policy: artifacts,
) )
@@ -218,11 +218,11 @@ def test_combine_uses_fit_split_for_factor_preselection(tmp_path, monkeypatch):
return next(iter(factor_signals.values())) return next(iter(factor_signals.values()))
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.evaluation.combination.FactorCombiner.equal_weight", "src.factorminer.factorminer.evaluation.combination.FactorCombiner.equal_weight",
_capture_equal_weight, _capture_equal_weight,
) )
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.evaluation.portfolio.PortfolioBacktester.quintile_backtest", "src.factorminer.factorminer.evaluation.portfolio.PortfolioBacktester.quintile_backtest",
lambda self, combined_signal, returns, transaction_cost_bps=0: { lambda self, combined_signal, returns, transaction_cost_bps=0: {
"ic_mean": 0.12, "ic_mean": 0.12,
"icir": 1.23, "icir": 1.23,
@@ -272,19 +272,19 @@ def test_visualize_defaults_factor_specific_plots_to_split_top_factor(tmp_path,
quintile_paths: list[str] = [] quintile_paths: list[str] = []
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.cli._load_runtime_dataset_for_analysis", "src.factorminer.factorminer.cli._load_runtime_dataset_for_analysis",
lambda cfg, data_path, mock: dataset, lambda cfg, data_path, mock: dataset,
) )
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.cli._recompute_analysis_artifacts", "src.factorminer.factorminer.cli._recompute_analysis_artifacts",
lambda library, dataset_arg, signal_failure_policy: artifacts, lambda library, dataset_arg, signal_failure_policy: artifacts,
) )
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.utils.visualization.plot_ic_timeseries", "src.factorminer.factorminer.utils.visualization.plot_ic_timeseries",
lambda ic_series, dates, rolling_window=21, title="", save_path=None: ic_paths.append(save_path), lambda ic_series, dates, rolling_window=21, title="", save_path=None: ic_paths.append(save_path),
) )
monkeypatch.setattr( monkeypatch.setattr(
"factorminer.utils.visualization.plot_quintile_returns", "src.factorminer.factorminer.utils.visualization.plot_quintile_returns",
lambda quintile_returns, title="", save_path=None: quintile_paths.append(save_path), lambda quintile_returns, title="", save_path=None: quintile_paths.append(save_path),
) )

4
src/factorminer/factorminer/tests/test_cli_helix.py
View File

@@ -8,8 +8,8 @@ from click.testing import CliRunner
import numpy as np import numpy as np
import pandas as pd import pandas as pd
from factorminer.cli import _build_core_mining_config, _prepare_data_arrays, main from src.factorminer.factorminer.cli import _build_core_mining_config, _prepare_data_arrays, main
from factorminer.utils.config import load_config from src.factorminer.factorminer.utils.config import load_config
def test_helix_cli_runs_with_mock_data(tmp_path): def test_helix_cli_runs_with_mock_data(tmp_path):

4
src/factorminer/factorminer/tests/test_combination.py
View File

@@ -5,8 +5,8 @@ from __future__ import annotations
import numpy as np import numpy as np
import pytest import pytest
from factorminer.evaluation.combination import FactorCombiner from src.factorminer.factorminer.evaluation.combination import FactorCombiner
from factorminer.evaluation.selection import FactorSelector from src.factorminer.factorminer.evaluation.selection import FactorSelector
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

4
src/factorminer/factorminer/tests/test_data.py
View File

@@ -6,8 +6,8 @@ import numpy as np
import pandas as pd import pandas as pd
import pytest import pytest
from factorminer.data.loader import load_market_data from src.factorminer.factorminer.data.loader import load_market_data
from factorminer.data.mock_data import MockConfig, generate_mock_data, generate_with_halts from src.factorminer.factorminer.data.mock_data import MockConfig, generate_mock_data, generate_with_halts
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

12
src/factorminer/factorminer/tests/test_debate.py
View File

@@ -4,12 +4,12 @@ from __future__ import annotations
import pytest import pytest
from factorminer.agent.critic import CriticAgent from src.factorminer.factorminer.agent.critic import CriticAgent
from factorminer.agent.debate import DebateConfig, DebateGenerator from src.factorminer.factorminer.agent.debate import DebateConfig, DebateGenerator
from factorminer.agent.llm_interface import MockProvider from src.factorminer.factorminer.agent.llm_interface import MockProvider
from factorminer.agent.output_parser import CandidateFactor from src.factorminer.factorminer.agent.output_parser import CandidateFactor
from factorminer.agent.prompt_builder import PromptBuilder from src.factorminer.factorminer.agent.prompt_builder import PromptBuilder
from factorminer.agent.specialists import ( from src.factorminer.factorminer.agent.specialists import (
SpecialistConfig, SpecialistConfig,
SpecialistPromptBuilder, SpecialistPromptBuilder,
) )

2
src/factorminer/factorminer/tests/test_evaluation.py
View File

@@ -5,7 +5,7 @@ from __future__ import annotations
import numpy as np import numpy as np
import pytest import pytest
from factorminer.evaluation.metrics import ( from src.factorminer.factorminer.evaluation.metrics import (
compute_factor_stats, compute_factor_stats,
compute_ic, compute_ic,
compute_ic_mean, compute_ic_mean,

6
src/factorminer/factorminer/tests/test_expression_tree.py
View File

@@ -5,14 +5,14 @@ from __future__ import annotations
import numpy as np import numpy as np
import pytest import pytest
from factorminer.core.parser import parse, try_parse, tokenize from src.factorminer.factorminer.core.parser import parse, try_parse, tokenize
from factorminer.core.expression_tree import ( from src.factorminer.factorminer.core.expression_tree import (
ConstantNode, ConstantNode,
ExpressionTree, ExpressionTree,
LeafNode, LeafNode,
OperatorNode, OperatorNode,
) )
from factorminer.core.types import OPERATOR_REGISTRY, get_operator from src.factorminer.factorminer.core.types import OPERATOR_REGISTRY, get_operator
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

8
src/factorminer/factorminer/tests/test_helix_loop.py
View File

@@ -11,10 +11,10 @@ try:
except ImportError: except ImportError:
HAS_HELIX = False HAS_HELIX = False
from factorminer.agent.llm_interface import MockProvider from src.factorminer.factorminer.agent.llm_interface import MockProvider
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.config import MiningConfig from src.factorminer.factorminer.core.config import MiningConfig
from factorminer.core.ralph_loop import EvaluationResult from src.factorminer.factorminer.core.ralph_loop import EvaluationResult
pytestmark = pytest.mark.skipif(not HAS_HELIX, reason="helix_loop not yet built") pytestmark = pytest.mark.skipif(not HAS_HELIX, reason="helix_loop not yet built")

2
src/factorminer/factorminer/tests/test_knowledge_graph.py
View File

@@ -4,7 +4,7 @@ from __future__ import annotations
import pytest import pytest
from factorminer.memory.knowledge_graph import ( from src.factorminer.factorminer.memory.knowledge_graph import (
EdgeType, EdgeType,
FactorKnowledgeGraph, FactorKnowledgeGraph,
FactorNode, FactorNode,

2
src/factorminer/factorminer/tests/test_library.py
View File

@@ -5,7 +5,7 @@ from __future__ import annotations
import numpy as np import numpy as np
import pytest import pytest
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

16
src/factorminer/factorminer/tests/test_memory.py
View File

@@ -8,20 +8,20 @@ from pathlib import Path
import pytest import pytest
from factorminer.memory.experience_memory import ExperienceMemoryManager from src.factorminer.factorminer.memory.experience_memory import ExperienceMemoryManager
from factorminer.memory.embeddings import FormulaEmbedder from src.factorminer.factorminer.memory.embeddings import FormulaEmbedder
from factorminer.memory.kg_retrieval import retrieve_memory_enhanced from src.factorminer.factorminer.memory.kg_retrieval import retrieve_memory_enhanced
from factorminer.memory.knowledge_graph import FactorKnowledgeGraph, FactorNode from src.factorminer.factorminer.memory.knowledge_graph import FactorKnowledgeGraph, FactorNode
from factorminer.memory.memory_store import ( from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory, ExperienceMemory,
ForbiddenDirection, ForbiddenDirection,
MiningState, MiningState,
StrategicInsight, StrategicInsight,
SuccessPattern, SuccessPattern,
) )
from factorminer.memory.formation import form_memory from src.factorminer.factorminer.memory.formation import form_memory
from factorminer.memory.evolution import evolve_memory from src.factorminer.factorminer.memory.evolution import evolve_memory
from factorminer.memory.retrieval import retrieve_memory from src.factorminer.factorminer.memory.retrieval import retrieve_memory
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

2
src/factorminer/factorminer/tests/test_operators.py
View File

@@ -5,7 +5,7 @@ from __future__ import annotations
import numpy as np import numpy as np
import pytest import pytest
from factorminer.operators.registry import execute_operator, get_operator, list_operators, implemented_operators from src.factorminer.factorminer.operators.registry import execute_operator, get_operator, list_operators, implemented_operators
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

14
src/factorminer/factorminer/tests/test_provenance.py
View File

@@ -6,13 +6,13 @@ import json
import numpy as np import numpy as np
from factorminer.agent.llm_interface import MockProvider from src.factorminer.factorminer.agent.llm_interface import MockProvider
from factorminer.core.factor_library import Factor from src.factorminer.factorminer.core.factor_library import Factor
from factorminer.core.library_io import load_library from src.factorminer.factorminer.core.library_io import load_library
from factorminer.core.config import MiningConfig from src.factorminer.factorminer.core.config import MiningConfig
from factorminer.core.helix_loop import HelixLoop from src.factorminer.factorminer.core.helix_loop import HelixLoop
from factorminer.core.ralph_loop import EvaluationResult from src.factorminer.factorminer.core.ralph_loop import EvaluationResult
from factorminer.core.session import MiningSession from src.factorminer.factorminer.core.session import MiningSession
def test_factor_provenance_roundtrip(): def test_factor_provenance_roundtrip():

8
src/factorminer/factorminer/tests/test_ralph_loop.py
View File

@@ -23,9 +23,9 @@ from typing import Any, Dict, Optional
import numpy as np import numpy as np
import pytest import pytest
from factorminer.agent.llm_interface import MockProvider from src.factorminer.factorminer.agent.llm_interface import MockProvider
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.ralph_loop import ( from src.factorminer.factorminer.core.ralph_loop import (
BudgetTracker, BudgetTracker,
EvaluationResult, EvaluationResult,
FactorGenerator, FactorGenerator,
@@ -33,7 +33,7 @@ from factorminer.core.ralph_loop import (
RalphLoop, RalphLoop,
ValidationPipeline, ValidationPipeline,
) )
from factorminer.memory.memory_store import ExperienceMemory from src.factorminer.factorminer.memory.memory_store import ExperienceMemory
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

2
src/factorminer/factorminer/tests/test_regime.py
View File

@@ -5,7 +5,7 @@ from __future__ import annotations
import numpy as np import numpy as np
import pytest import pytest
from factorminer.evaluation.regime import ( from src.factorminer.factorminer.evaluation.regime import (
MarketRegime, MarketRegime,
RegimeAwareEvaluator, RegimeAwareEvaluator,
RegimeConfig, RegimeConfig,

12
src/factorminer/factorminer/tests/test_research.py
View File

@@ -8,17 +8,17 @@ import numpy as np
import pandas as pd import pandas as pd
import pytest import pytest
from factorminer.core.factor_library import Factor from src.factorminer.factorminer.core.factor_library import Factor
from factorminer.data.tensor_builder import TargetSpec, compute_targets from src.factorminer.factorminer.data.tensor_builder import TargetSpec, compute_targets
from factorminer.evaluation.portfolio import PortfolioBacktester from src.factorminer.factorminer.evaluation.portfolio import PortfolioBacktester
from factorminer.evaluation.research import ( from src.factorminer.factorminer.evaluation.research import (
FactorGeometryDiagnostics, FactorGeometryDiagnostics,
build_score_vector, build_score_vector,
passes_research_admission, passes_research_admission,
run_research_model_suite, run_research_model_suite,
) )
from factorminer.evaluation.runtime import DatasetSplit, EvaluationDataset, evaluate_factors from src.factorminer.factorminer.evaluation.runtime import DatasetSplit, EvaluationDataset, evaluate_factors
from factorminer.utils.config import load_config from src.factorminer.factorminer.utils.config import load_config
def test_compute_targets_supports_multiple_horizons(): def test_compute_targets_supports_multiple_horizons():

8
src/factorminer/factorminer/tests/test_runtime_analysis.py
View File

@@ -9,10 +9,10 @@ import numpy as np
import pandas as pd import pandas as pd
import pytest import pytest
from factorminer.core.factor_library import Factor from src.factorminer.factorminer.core.factor_library import Factor
from factorminer.core.parser import try_parse from src.factorminer.factorminer.core.parser import try_parse
from factorminer.evaluation.metrics import compute_factor_stats from src.factorminer.factorminer.evaluation.metrics import compute_factor_stats
from factorminer.evaluation.runtime import ( from src.factorminer.factorminer.evaluation.runtime import (
DatasetSplit, DatasetSplit,
EvaluationDataset, EvaluationDataset,
SignalComputationError, SignalComputationError,

2
src/factorminer/factorminer/tests/test_significance.py
View File

@@ -5,7 +5,7 @@ from __future__ import annotations
import numpy as np import numpy as np
import pytest import pytest
from factorminer.evaluation.significance import ( from src.factorminer.factorminer.evaluation.significance import (
BootstrapCIResult, BootstrapCIResult,
BootstrapICTester, BootstrapICTester,
DeflatedSharpeCalculator, DeflatedSharpeCalculator,

8
src/factorminer/factorminer/utils/__init__.py
View File

@@ -1,6 +1,6 @@
"""Utility modules for FactorMiner.""" """Utility modules for FactorMiner."""
from factorminer.utils.config import ( from src.factorminer.factorminer.utils.config import (
AutoInventorConfig, AutoInventorConfig,
CapacityConfig, CapacityConfig,
CausalConfig, CausalConfig,
@@ -13,9 +13,9 @@ from factorminer.utils.config import (
SignificanceConfig, SignificanceConfig,
load_config, load_config,
) )
from factorminer.utils.reporting import MiningReporter from src.factorminer.factorminer.utils.reporting import MiningReporter
from factorminer.utils.tearsheet import FactorTearSheet from src.factorminer.factorminer.utils.tearsheet import FactorTearSheet
from factorminer.utils.visualization import ( from src.factorminer.factorminer.utils.visualization import (
plot_ablation_comparison, plot_ablation_comparison,
plot_correlation_heatmap, plot_correlation_heatmap,
plot_cost_pressure, plot_cost_pressure,

2
src/factorminer/factorminer/utils/config.py
View File

@@ -9,7 +9,7 @@ from typing import Any
import yaml import yaml
from factorminer.configs import DEFAULT_CONFIG_PATH from src.factorminer.factorminer.configs import DEFAULT_CONFIG_PATH
@dataclass @dataclass

2
src/factorminer/factorminer/utils/tearsheet.py
View File

@@ -15,7 +15,7 @@ import numpy as np
import pandas as pd import pandas as pd
from scipy.stats import rankdata from scipy.stats import rankdata
from factorminer.evaluation.metrics import ( from src.factorminer.factorminer.evaluation.metrics import (
compute_ic, compute_ic,
compute_icir, compute_icir,
compute_ic_mean, compute_ic_mean,

106
src/factorminer/pyproject.toml
View File

@@ -1,106 +0,0 @@
[build-system]
requires = ["setuptools>=68.0", "wheel"]
build-backend = "setuptools.build_meta"
[project]
name = "factorminer"
version = "0.1.0"
description = "LLM-powered quantitative factor mining with evolutionary search"
readme = "README.md"
license = "MIT"
requires-python = ">=3.10"
authors = [
{name = "FactorMiner Team"},
]
keywords = ["quantitative-finance", "factor-mining", "llm", "alpha-research"]
classifiers = [
"Development Status :: 3 - Alpha",
"Intended Audience :: Financial and Insurance Industry",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Office/Business :: Financial :: Investment",
]
dependencies = [
"numpy>=1.24",
"pandas>=2.0",
"scipy>=1.11",
"torch>=2.0",
"scikit-learn>=1.3",
"xgboost>=2.0",
"pyyaml>=6.0",
"click>=8.0",
"matplotlib>=3.7",
"seaborn>=0.12",
"tqdm>=4.65",
"statsmodels>=0.14.0",
"sympy>=1.13",
"networkx>=3.0",
]
[project.optional-dependencies]
gpu = [
"cupy-cuda12x; platform_system == 'Linux'",
]
llm = [
"openai",
"anthropic",
"google-generativeai",
"sentence-transformers>=2.0",
"faiss-cpu>=1.7",
]
dev = [
"pytest>=7.0",
"pytest-cov",
"ruff",
"mypy",
]
all = [
"cupy-cuda12x; platform_system == 'Linux'",
"openai",
"anthropic",
"google-generativeai",
"sentence-transformers>=2.0",
"faiss-cpu>=1.7",
"pytest>=7.0",
"pytest-cov",
"ruff",
"mypy",
]
[dependency-groups]
dev = [
"pytest>=7.0",
"pytest-cov",
"ruff",
"mypy",
]
[project.scripts]
factorminer = "factorminer.cli:main"
[project.urls]
Homepage = "https://github.com/minihellboy/factorminer"
Repository = "https://github.com/minihellboy/factorminer"
Issues = "https://github.com/minihellboy/factorminer/issues"
[tool.setuptools.packages.find]
include = ["factorminer*"]
[tool.ruff]
line-length = 100
target-version = "py310"
[tool.ruff.lint]
select = ["E", "F", "W", "I", "N", "UP"]
[tool.pytest.ini_options]
testpaths = ["factorminer/tests"]
addopts = "-v --tb=short"
[tool.mypy]
python_version = "3.10"
warn_return_any = true
warn_unused_configs = true

16
src/factorminer/run_demo.py
View File

@@ -20,17 +20,17 @@ sys.path.insert(0, ".")
import numpy as np import numpy as np
np.random.seed(42) np.random.seed(42)
from factorminer.data.mock_data import generate_mock_data, MockConfig from src.factorminer.factorminer.data.mock_data import generate_mock_data, MockConfig
from factorminer.data.preprocessor import preprocess from src.factorminer.factorminer.data.preprocessor import preprocess
from factorminer.core.parser import parse, try_parse from src.factorminer.factorminer.core.parser import parse, try_parse
from factorminer.core.factor_library import Factor, FactorLibrary from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import PAPER_FACTORS from src.factorminer.factorminer.core.library_io import PAPER_FACTORS
from factorminer.evaluation.metrics import ( from src.factorminer.factorminer.evaluation.metrics import (
compute_ic, compute_icir, compute_ic_mean, compute_ic_win_rate, compute_ic, compute_icir, compute_ic_mean, compute_ic_win_rate,
compute_factor_stats, compute_factor_stats,
) )
from factorminer.evaluation.combination import FactorCombiner from src.factorminer.factorminer.evaluation.combination import FactorCombiner
from factorminer.evaluation.selection import FactorSelector from src.factorminer.factorminer.evaluation.selection import FactorSelector
def section(title): def section(title):

2
src/factorminer/run_phase2_benchmark.py
View File

@@ -500,7 +500,7 @@ def main() -> None:
# Load benchmark modules directly to avoid triggering the package __init__ # Load benchmark modules directly to avoid triggering the package __init__
_hb = _load_module_direct( _hb = _load_module_direct(
"factorminer.benchmark.helix_benchmark", "src.factorminer.factorminer.benchmark.helix_benchmark",
_REPO_ROOT / "factorminer" / "benchmark" / "helix_benchmark.py", _REPO_ROOT / "factorminer" / "benchmark" / "helix_benchmark.py",
) )
_json_safe = _hb._json_safe _json_safe = _hb._json_safe

3636
src/factorminer/uv.lock generated
View File

File diff suppressed because it is too large Load Diff