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"
__author__ = "FactorMiner Team"
from factorminer.utils.config import (
from src.factorminer.factorminer.utils.config import (
Config,
MiningConfig,
EvaluationConfig,

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

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

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

@@ -22,9 +22,9 @@ from collections import Counter
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Set, Tuple
from factorminer.agent.llm_interface import LLMProvider
from factorminer.agent.output_parser import CandidateFactor
from factorminer.agent.prompt_builder import normalize_factor_references
from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from src.factorminer.factorminer.agent.output_parser import CandidateFactor
from src.factorminer.factorminer.agent.prompt_builder import normalize_factor_references
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 typing import Any, Dict, List, Optional
from factorminer.agent.critic import CriticAgent, CriticScore
from factorminer.agent.factor_generator import FactorGenerator
from factorminer.agent.llm_interface import LLMProvider
from factorminer.agent.output_parser import CandidateFactor
from factorminer.agent.prompt_builder import (
from src.factorminer.factorminer.agent.critic import CriticAgent, CriticScore
from src.factorminer.factorminer.agent.factor_generator import FactorGenerator
from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from src.factorminer.factorminer.agent.output_parser import CandidateFactor
from src.factorminer.factorminer.agent.prompt_builder import (
PromptBuilder,
normalize_factor_references,
)
from factorminer.agent.specialists import (
from src.factorminer.factorminer.agent.specialists import (
DEFAULT_SPECIALISTS,
SpecialistAgent,
SpecialistConfig,

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

@@ -10,9 +10,9 @@ import logging
import time
from typing import Any, Dict, List, Optional
from factorminer.agent.llm_interface import LLMProvider
from factorminer.agent.output_parser import CandidateFactor, parse_llm_output
from factorminer.agent.prompt_builder import PromptBuilder
from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from src.factorminer.factorminer.agent.output_parser import CandidateFactor, parse_llm_output
from src.factorminer.factorminer.agent.prompt_builder import PromptBuilder
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 typing import Dict, List, Optional, Tuple
from factorminer.core.expression_tree import ExpressionTree
from factorminer.core.parser import parse, try_parse
from factorminer.core.types import OperatorType, OPERATOR_REGISTRY
from src.factorminer.factorminer.core.expression_tree import ExpressionTree
from src.factorminer.factorminer.core.parser import parse, try_parse
from src.factorminer.factorminer.core.types import OperatorType, OPERATOR_REGISTRY
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 factorminer.core.types import (
from src.factorminer.factorminer.core.types import (
FEATURES,
OPERATOR_REGISTRY,
OperatorSpec,

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

@@ -13,9 +13,9 @@ import logging
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional
from factorminer.agent.llm_interface import LLMProvider
from factorminer.agent.output_parser import CandidateFactor, parse_llm_output
from factorminer.agent.prompt_builder import (
from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from src.factorminer.factorminer.agent.output_parser import CandidateFactor, parse_llm_output
from src.factorminer.factorminer.agent.prompt_builder import (
SYSTEM_PROMPT,
PromptBuilder,
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."""
from factorminer.benchmark.runtime import (
from src.factorminer.factorminer.benchmark.runtime import (
BenchmarkManifest,
build_benchmark_library,
evaluate_frozen_set,
@@ -13,7 +13,7 @@ from factorminer.benchmark.runtime import (
run_table1_benchmark,
select_frozen_top_k,
)
from factorminer.benchmark.helix_benchmark import (
from src.factorminer.factorminer.benchmark.helix_benchmark import (
HelixBenchmark,
BenchmarkResult,
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 pandas as pd
import factorminer.core.helix_loop as helix_loop_module
import factorminer.core.ralph_loop as ralph_loop_module
from factorminer.agent.debate import DebateConfig as RuntimeDebateConfig
from factorminer.agent.llm_interface import MockProvider
from factorminer.benchmark.helix_benchmark import AblationResult, MethodResult
from factorminer.core.config import MiningConfig
from factorminer.core.helix_loop import HelixLoop
from factorminer.core.factor_library import FactorLibrary
from factorminer.evaluation.capacity import CapacityConfig as RuntimeCapacityConfig
from factorminer.evaluation.causal import CausalConfig as RuntimeCausalConfig
from factorminer.evaluation.regime import RegimeConfig as RuntimeRegimeConfig
from factorminer.evaluation.runtime import (
import src.factorminer.factorminer.core.helix_loop as helix_loop_module
import src.factorminer.factorminer.core.ralph_loop as ralph_loop_module
from src.factorminer.factorminer.agent.debate import DebateConfig as RuntimeDebateConfig
from src.factorminer.factorminer.agent.llm_interface import MockProvider
from src.factorminer.factorminer.benchmark.helix_benchmark import AblationResult, MethodResult
from src.factorminer.factorminer.core.config import MiningConfig
from src.factorminer.factorminer.core.helix_loop import HelixLoop
from src.factorminer.factorminer.core.factor_library import FactorLibrary
from src.factorminer.factorminer.evaluation.capacity import CapacityConfig as RuntimeCapacityConfig
from src.factorminer.factorminer.evaluation.causal import CausalConfig as RuntimeCausalConfig
from src.factorminer.factorminer.evaluation.regime import RegimeConfig as RuntimeRegimeConfig
from src.factorminer.factorminer.evaluation.runtime import (
DatasetSplit,
EvaluationDataset,
evaluate_factors,
)
from factorminer.evaluation.significance import (
from src.factorminer.factorminer.evaluation.significance import (
SignificanceConfig as RuntimeSignificanceConfig,
)
from factorminer.benchmark.runtime import (
from src.factorminer.factorminer.benchmark.runtime import (
build_benchmark_library,
evaluate_frozen_set,
select_frozen_top_k,
)
from factorminer.memory.memory_store import ExperienceMemory
from src.factorminer.factorminer.memory.memory_store import ExperienceMemory
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
from factorminer.core.library_io import PAPER_FACTORS
from src.factorminer.factorminer.core.library_io import PAPER_FACTORS
@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.
import importlib.util as _ilu, pathlib as _pl, sys as _sys
_cat_path = _pl.Path(__file__).parent / "catalogs.py"
if "factorminer.benchmark.catalogs" not in _sys.modules:
_spec = _ilu.spec_from_file_location("factorminer.benchmark.catalogs", str(_cat_path))
if "src.factorminer.factorminer.benchmark.catalogs" not in _sys.modules:
_spec = _ilu.spec_from_file_location("src.factorminer.factorminer.benchmark.catalogs", str(_cat_path))
_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)
_cat = _sys.modules["factorminer.benchmark.catalogs"]
_cat = _sys.modules["src.factorminer.factorminer.benchmark.catalogs"]
ALPHA101_CLASSIC = _cat.ALPHA101_CLASSIC
build_alpha101_adapted = _cat.build_alpha101_adapted
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 pandas as pd
from factorminer.benchmark.catalogs import (
from src.factorminer.factorminer.benchmark.catalogs import (
CandidateEntry,
build_alpha101_adapted,
build_alphaagent_style,
@@ -27,10 +27,10 @@ from factorminer.benchmark.catalogs import (
entries_from_library,
ALPHA101_CLASSIC,
)
from factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import load_library
from factorminer.core.session import MiningSession
from factorminer.evaluation.runtime import (
from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from src.factorminer.factorminer.core.library_io import load_library
from src.factorminer.factorminer.core.session import MiningSession
from src.factorminer.factorminer.evaluation.runtime import (
EvaluationDataset,
FactorEvaluationArtifact,
compute_correlation_matrix,

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

@@ -11,7 +11,7 @@ from pathlib import Path
import click
import numpy as np
from factorminer.utils.config import load_config
from src.factorminer.factorminer.utils.config import load_config
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."""
from factorminer.core.expression_tree import (
from src.factorminer.factorminer.core.expression_tree import (
ConstantNode,
ExpressionTree,
LeafNode,
Node,
OperatorNode,
)
from factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import (
from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from src.factorminer.factorminer.core.library_io import (
export_csv,
export_formulas,
import_from_paper,
load_library,
save_library,
)
from factorminer.core.parser import parse, try_parse
from factorminer.core.ralph_loop import RalphLoop
from factorminer.core.helix_loop import HelixLoop
from factorminer.core.session import MiningSession
from factorminer.core.config import MiningConfig as CoreMiningConfig
from factorminer.core.types import (
from src.factorminer.factorminer.core.parser import parse, try_parse
from src.factorminer.factorminer.core.ralph_loop import RalphLoop
from src.factorminer.factorminer.core.helix_loop import HelixLoop
from src.factorminer.factorminer.core.session import MiningSession
from src.factorminer.factorminer.core.config import MiningConfig as CoreMiningConfig
from src.factorminer.factorminer.core.types import (
FEATURES,
FEATURE_SET,
OPERATOR_REGISTRY,
@@ -29,7 +29,7 @@ from factorminer.core.types import (
SignatureType,
get_operator,
)
from factorminer.core.canonicalizer import FormulaCanonicalizer
from src.factorminer.factorminer.core.canonicalizer import FormulaCanonicalizer
__all__ = [
# Expression tree

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

@@ -21,7 +21,7 @@ from typing import Dict, List, Optional
import sympy
from sympy import Abs, Float, Function, Symbol, log, sqrt
from factorminer.core.expression_tree import (
from src.factorminer.factorminer.core.expression_tree import (
ConstantNode,
ExpressionTree,
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
from factorminer.core.types import (
from src.factorminer.factorminer.core.types import (
FEATURE_SET,
OperatorSpec,
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
from factorminer.core.ralph_loop import (
from src.factorminer.factorminer.core.ralph_loop import (
BudgetTracker,
EvaluationResult,
FactorGenerator,
RalphLoop,
ValidationPipeline,
)
from factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.parser import try_parse
from factorminer.evaluation.metrics import compute_ic
from factorminer.memory.memory_store import ExperienceMemory
from factorminer.memory.retrieval import retrieve_memory
from factorminer.memory.formation import form_memory
from factorminer.memory.evolution import evolve_memory
from factorminer.agent.llm_interface import LLMProvider
from factorminer.utils.logging import IterationRecord, FactorRecord
from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from src.factorminer.factorminer.core.parser import try_parse
from src.factorminer.factorminer.evaluation.metrics import compute_ic
from src.factorminer.factorminer.memory.memory_store import ExperienceMemory
from src.factorminer.factorminer.memory.retrieval import retrieve_memory
from src.factorminer.factorminer.memory.formation import form_memory
from src.factorminer.factorminer.memory.evolution import evolve_memory
from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from src.factorminer.factorminer.utils.logging import IterationRecord, FactorRecord
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
from factorminer.core.factor_library import Factor, FactorLibrary
from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
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 typing import Dict, List, Optional, Tuple
from factorminer.core.expression_tree import (
from src.factorminer.factorminer.core.expression_tree import (
ConstantNode,
ExpressionTree,
LeafNode,
Node,
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
from factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import save_library, load_library
from factorminer.core.provenance import build_factor_provenance, build_run_manifest
from factorminer.core.parser import try_parse
from factorminer.core.session import MiningSession
from factorminer.core.types import FEATURES
from factorminer.memory.experience_memory import ExperienceMemoryManager
from factorminer.memory.memory_store import ExperienceMemory
from factorminer.memory.retrieval import retrieve_memory
from factorminer.memory.formation import form_memory
from factorminer.memory.evolution import evolve_memory
from factorminer.agent.llm_interface import LLMProvider, MockProvider
from factorminer.agent.prompt_builder import PromptBuilder
from factorminer.evaluation.metrics import (
from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from src.factorminer.factorminer.core.library_io import save_library, load_library
from src.factorminer.factorminer.core.provenance import build_factor_provenance, build_run_manifest
from src.factorminer.factorminer.core.parser import try_parse
from src.factorminer.factorminer.core.session import MiningSession
from src.factorminer.factorminer.core.types import FEATURES
from src.factorminer.factorminer.memory.experience_memory import ExperienceMemoryManager
from src.factorminer.factorminer.memory.memory_store import ExperienceMemory
from src.factorminer.factorminer.memory.retrieval import retrieve_memory
from src.factorminer.factorminer.memory.formation import form_memory
from src.factorminer.factorminer.memory.evolution import evolve_memory
from src.factorminer.factorminer.agent.llm_interface import LLMProvider, MockProvider
from src.factorminer.factorminer.agent.prompt_builder import PromptBuilder
from src.factorminer.factorminer.evaluation.metrics import (
compute_factor_stats,
compute_ic,
compute_ic_mean,
compute_ic_win_rate,
compute_icir,
)
from factorminer.evaluation.research import (
from src.factorminer.factorminer.evaluation.research import (
build_score_vector,
compute_factor_geometry,
passes_research_admission,
)
from factorminer.evaluation.runtime import SignalComputationError, compute_tree_signals
from factorminer.utils.logging import (
from src.factorminer.factorminer.evaluation.runtime import SignalComputationError, compute_tree_signals
from src.factorminer.factorminer.utils.logging import (
IterationRecord,
FactorRecord,
MiningSessionLogger,

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

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

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

@@ -1,18 +1,18 @@
"""Multi-stage factor evaluation and validation pipeline."""
from factorminer.evaluation.admission import (
from src.factorminer.factorminer.evaluation.admission import (
AdmissionDecision,
StockThresholds,
check_admission,
check_replacement,
)
from factorminer.evaluation.correlation import (
from src.factorminer.factorminer.evaluation.correlation import (
IncrementalCorrelationMatrix,
batch_spearman_correlation,
batch_spearman_pairwise,
compute_correlation_batch,
)
from factorminer.evaluation.metrics import (
from src.factorminer.factorminer.evaluation.metrics import (
compute_factor_stats,
compute_ic,
compute_ic_mean,
@@ -23,7 +23,7 @@ from factorminer.evaluation.metrics import (
compute_quintile_returns,
compute_turnover,
)
from factorminer.evaluation.pipeline import (
from src.factorminer.factorminer.evaluation.pipeline import (
CandidateFactor,
EvaluationResult,
FactorLibraryView,
@@ -31,10 +31,10 @@ from factorminer.evaluation.pipeline import (
ValidationPipeline,
run_evaluation_pipeline,
)
from factorminer.evaluation.combination import FactorCombiner
from factorminer.evaluation.selection import FactorSelector
from factorminer.evaluation.portfolio import PortfolioBacktester
from factorminer.evaluation.backtest import (
from src.factorminer.factorminer.evaluation.combination import FactorCombiner
from src.factorminer.factorminer.evaluation.selection import FactorSelector
from src.factorminer.factorminer.evaluation.portfolio import PortfolioBacktester
from src.factorminer.factorminer.evaluation.backtest import (
SplitWindow,
DrawdownResult,
train_test_split,
@@ -48,7 +48,7 @@ from factorminer.evaluation.backtest import (
compute_sharpe_ratio,
compute_calmar_ratio,
)
from factorminer.evaluation.regime import (
from src.factorminer.factorminer.evaluation.regime import (
MarketRegime,
RegimeConfig,
RegimeClassification,
@@ -56,7 +56,7 @@ from factorminer.evaluation.regime import (
RegimeICResult,
RegimeAwareEvaluator,
)
from factorminer.evaluation.capacity import (
from src.factorminer.factorminer.evaluation.capacity import (
CapacityConfig,
CapacityEstimate,
CapacityEstimator,
@@ -64,12 +64,12 @@ from factorminer.evaluation.capacity import (
MarketImpactModel,
NetCostResult,
)
from factorminer.evaluation.causal import (
from src.factorminer.factorminer.evaluation.causal import (
CausalConfig,
CausalTestResult,
CausalValidator,
)
from factorminer.evaluation.significance import (
from src.factorminer.factorminer.evaluation.significance import (
BootstrapCIResult,
BootstrapICTester,
DeflatedSharpeCalculator,
@@ -79,7 +79,7 @@ from factorminer.evaluation.significance import (
SignificanceConfig,
check_significance,
)
from factorminer.evaluation.research import (
from src.factorminer.factorminer.evaluation.research import (
FactorGeometryDiagnostics,
FactorScoreVector,
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
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
from factorminer.evaluation.metrics import compute_ic
from src.factorminer.factorminer.evaluation.metrics import compute_ic
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
from factorminer.evaluation.admission import (
from src.factorminer.factorminer.evaluation.admission import (
AdmissionDecision,
check_admission,
check_replacement,
)
from factorminer.evaluation.correlation import (
from src.factorminer.factorminer.evaluation.correlation import (
batch_spearman_correlation,
batch_spearman_pairwise,
compute_correlation_batch,
)
from factorminer.evaluation.metrics import (
from src.factorminer.factorminer.evaluation.metrics import (
compute_factor_stats,
compute_ic,
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
from factorminer.evaluation.backtest import rolling_splits
from factorminer.evaluation.metrics import compute_factor_stats, compute_pairwise_correlation
from factorminer.evaluation.portfolio import PortfolioBacktester
from factorminer.evaluation.regime import RegimeAwareEvaluator, RegimeConfig, RegimeDetector
from factorminer.evaluation.selection import FactorSelector
from factorminer.evaluation.significance import BootstrapICTester, SignificanceConfig
from src.factorminer.factorminer.evaluation.backtest import rolling_splits
from src.factorminer.factorminer.evaluation.metrics import compute_factor_stats, compute_pairwise_correlation
from src.factorminer.factorminer.evaluation.portfolio import PortfolioBacktester
from src.factorminer.factorminer.evaluation.regime import RegimeAwareEvaluator, RegimeConfig, RegimeDetector
from src.factorminer.factorminer.evaluation.selection import FactorSelector
from src.factorminer.factorminer.evaluation.significance import BootstrapICTester, SignificanceConfig
@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 pandas as pd
from factorminer.core.factor_library import Factor
from factorminer.core.parser import try_parse
from factorminer.data.tensor_builder import TargetSpec, compute_targets
from factorminer.evaluation.metrics import (
from src.factorminer.factorminer.core.factor_library import Factor
from src.factorminer.factorminer.core.parser import try_parse
from src.factorminer.factorminer.data.tensor_builder import TargetSpec, compute_targets
from src.factorminer.factorminer.evaluation.metrics import (
compute_factor_stats,
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
"""
from factorminer.memory.memory_store import (
from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory,
ForbiddenDirection,
MiningState,
StrategicInsight,
SuccessPattern,
)
from factorminer.memory.formation import form_memory
from factorminer.memory.evolution import evolve_memory
from factorminer.memory.retrieval import retrieve_memory
from factorminer.memory.experience_memory import ExperienceMemoryManager
from src.factorminer.factorminer.memory.formation import form_memory
from src.factorminer.factorminer.memory.evolution import evolve_memory
from src.factorminer.factorminer.memory.retrieval import retrieve_memory
from src.factorminer.factorminer.memory.experience_memory import ExperienceMemoryManager
# Phase 2: Optional imports (graceful if dependencies missing)
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 factorminer.memory.memory_store import (
from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory,
ForbiddenDirection,
MiningState,

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

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

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

@@ -13,7 +13,7 @@ import re
from collections import Counter, defaultdict
from typing import Any, Dict, List, Optional, Tuple
from factorminer.memory.memory_store import (
from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory,
ForbiddenDirection,
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 factorminer.memory.memory_store import ExperienceMemory
from factorminer.memory.retrieval import retrieve_memory
from src.factorminer.factorminer.memory.memory_store import ExperienceMemory
from src.factorminer.factorminer.memory.retrieval import retrieve_memory
# Optional imports -- presence checked at call time
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
from factorminer.evaluation.regime import RegimeState, StreamingRegimeDetector, StreamingRegimeConfig
from factorminer.memory.memory_store import (
from src.factorminer.factorminer.evaluation.regime import RegimeState, StreamingRegimeDetector, StreamingRegimeConfig
from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory,
StrategicInsight,
SuccessPattern,
)
from factorminer.memory.evolution import (
from src.factorminer.factorminer.memory.evolution import (
apply_confidence_decay,
bump_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__)

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 factorminer.memory.memory_store import (
from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory,
ForbiddenDirection,
MiningState,

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

@@ -3,7 +3,7 @@
Exports the central registry and all operator category modules.
"""
from factorminer.operators.registry import (
from src.factorminer.factorminer.operators.registry import (
OPERATOR_REGISTRY,
execute_operator,
get_impl,
@@ -11,7 +11,7 @@ from factorminer.operators.registry import (
implemented_operators,
list_operators,
)
from factorminer.operators.gpu_backend import (
from src.factorminer.factorminer.operators.gpu_backend import (
DeviceManager,
batch_execute,
device_manager,
@@ -19,12 +19,12 @@ from factorminer.operators.gpu_backend import (
to_tensor,
torch_available,
)
from factorminer.operators.auto_inventor import (
from src.factorminer.factorminer.operators.auto_inventor import (
OperatorInventor,
ProposedOperator,
ValidationResult,
)
from factorminer.operators.custom import (
from src.factorminer.factorminer.operators.custom import (
CustomOperator,
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
from factorminer.agent.llm_interface import LLMProvider
from factorminer.core.types import OPERATOR_REGISTRY, OperatorSpec
from src.factorminer.factorminer.agent.llm_interface import LLMProvider
from src.factorminer.factorminer.core.types import OPERATOR_REGISTRY, OperatorSpec
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
from factorminer.core.types import (
from src.factorminer.factorminer.core.types import (
OPERATOR_REGISTRY as SPEC_REGISTRY,
OperatorSpec,
OperatorType,
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__)

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
from factorminer.core.types import OPERATOR_REGISTRY as SPEC_REGISTRY
from factorminer.core.types import OperatorSpec, OperatorType
from src.factorminer.factorminer.core.types import OPERATOR_REGISTRY as SPEC_REGISTRY
from src.factorminer.factorminer.core.types import OperatorSpec, OperatorType
from factorminer.operators.arithmetic import ARITHMETIC_OPS
from factorminer.operators.statistical import STATISTICAL_OPS
from factorminer.operators.timeseries import TIMESERIES_OPS
from factorminer.operators.crosssectional import CROSSSECTIONAL_OPS
from factorminer.operators.smoothing import SMOOTHING_OPS
from factorminer.operators.regression import REGRESSION_OPS
from factorminer.operators.logical import LOGICAL_OPS
from src.factorminer.factorminer.operators.arithmetic import ARITHMETIC_OPS
from src.factorminer.factorminer.operators.statistical import STATISTICAL_OPS
from src.factorminer.factorminer.operators.timeseries import TIMESERIES_OPS
from src.factorminer.factorminer.operators.crosssectional import CROSSSECTIONAL_OPS
from src.factorminer.factorminer.operators.smoothing import SMOOTHING_OPS
from src.factorminer.factorminer.operators.regression import REGRESSION_OPS
from src.factorminer.factorminer.operators.logical import LOGICAL_OPS
try:
import torch

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

@@ -5,8 +5,8 @@ from __future__ import annotations
import numpy as np
import pytest
from factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.memory.experience_memory import ExperienceMemoryManager
from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
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 pytest
from factorminer.operators.auto_inventor import (
from src.factorminer.factorminer.operators.auto_inventor import (
OperatorInventor,
ProposedOperator,
_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
import numpy as np
from factorminer.benchmark.runtime import (
from src.factorminer.factorminer.benchmark.runtime import (
build_benchmark_library,
run_table1_benchmark,
select_frozen_top_k,
)
from factorminer.benchmark.helix_benchmark import StatisticalComparisonTests, _json_safe
from factorminer.cli import main
from factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import save_library
from factorminer.core.session import MiningSession
from factorminer.evaluation.runtime import FactorEvaluationArtifact
from factorminer.utils.config import load_config
from src.factorminer.factorminer.benchmark.helix_benchmark import StatisticalComparisonTests, _json_safe
from src.factorminer.factorminer.cli import main
from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from src.factorminer.factorminer.core.library_io import save_library
from src.factorminer.factorminer.core.session import MiningSession
from src.factorminer.factorminer.evaluation.runtime import FactorEvaluationArtifact
from src.factorminer.factorminer.utils.config import load_config
from run_phase2_benchmark import (
_build_phase2_manifest,
_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()
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)
monkeypatch.setattr(
"factorminer.benchmark.runtime.load_benchmark_dataset",
"src.factorminer.factorminer.benchmark.runtime.load_benchmark_dataset",
lambda *args, **kwargs: (SimpleNamespace(), "freeze-hash"),
)
monkeypatch.setattr(
"factorminer.benchmark.runtime.evaluate_factors",
"src.factorminer.factorminer.benchmark.runtime.evaluate_factors",
lambda *args, **kwargs: [artifact],
)
monkeypatch.setattr(
"factorminer.benchmark.runtime.evaluate_frozen_set",
"src.factorminer.factorminer.benchmark.runtime.evaluate_frozen_set",
lambda frozen, dataset, **kwargs: {
"factor_count": len(frozen),
"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 = []
monkeypatch.setattr(
"factorminer.benchmark.runtime.load_benchmark_dataset",
"src.factorminer.factorminer.benchmark.runtime.load_benchmark_dataset",
lambda *args, **kwargs: (_runtime_dataset_stub(), "dataset-hash"),
)
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")),
)
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)],
)
monkeypatch.setattr(
"factorminer.benchmark.runtime.evaluate_frozen_set",
"src.factorminer.factorminer.benchmark.runtime.evaluate_frozen_set",
lambda frozen, dataset, **kwargs: {
"factor_count": len(frozen),
"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")
return _single_factor_library()
monkeypatch.setattr("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.ralph_loop.RalphLoop.run", _fake_ralph_run)
monkeypatch.setattr("src.factorminer.factorminer.core.helix_loop.HelixLoop.run", _fake_helix_run)
payload = run_table1_benchmark(
cfg,
@@ -455,7 +455,7 @@ def test_table1_runtime_methods_fail_loudly_without_catalog_fallback(monkeypatch
fallback_called = {"value": False}
monkeypatch.setattr(
"factorminer.benchmark.runtime.load_benchmark_dataset",
"src.factorminer.factorminer.benchmark.runtime.load_benchmark_dataset",
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
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(
"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")),
)

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

@@ -6,8 +6,8 @@ import time
import pytest
from factorminer.core.canonicalizer import FormulaCanonicalizer
from factorminer.core.parser import parse
from src.factorminer.factorminer.core.canonicalizer import FormulaCanonicalizer
from src.factorminer.factorminer.core.parser import parse
@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 pytest
from factorminer.evaluation.capacity import (
from src.factorminer.factorminer.evaluation.capacity import (
CapacityConfig,
CapacityEstimator,
MarketImpactModel,

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

@@ -5,7 +5,7 @@ from __future__ import annotations
import numpy as np
import pytest
from factorminer.evaluation.causal import CausalConfig, CausalTestResult, CausalValidator
from src.factorminer.factorminer.evaluation.causal import CausalConfig, CausalTestResult, CausalValidator
@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
import numpy as np
from factorminer.cli import main
from factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import save_library
from factorminer.evaluation.runtime import DatasetSplit, FactorEvaluationArtifact
from src.factorminer.factorminer.cli import main
from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from src.factorminer.factorminer.core.library_io import save_library
from src.factorminer.factorminer.evaluation.runtime import DatasetSplit, FactorEvaluationArtifact
@dataclass
@@ -160,11 +160,11 @@ def test_evaluate_recomputes_and_selects_top_k_by_train_split(tmp_path, monkeypa
]
monkeypatch.setattr(
"factorminer.cli._load_runtime_dataset_for_analysis",
"src.factorminer.factorminer.cli._load_runtime_dataset_for_analysis",
lambda cfg, data_path, mock: dataset,
)
monkeypatch.setattr(
"factorminer.cli._recompute_analysis_artifacts",
"src.factorminer.factorminer.cli._recompute_analysis_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] = []
monkeypatch.setattr(
"factorminer.cli._load_runtime_dataset_for_analysis",
"src.factorminer.factorminer.cli._load_runtime_dataset_for_analysis",
lambda cfg, data_path, mock: dataset,
)
monkeypatch.setattr(
"factorminer.cli._recompute_analysis_artifacts",
"src.factorminer.factorminer.cli._recompute_analysis_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()))
monkeypatch.setattr(
"factorminer.evaluation.combination.FactorCombiner.equal_weight",
"src.factorminer.factorminer.evaluation.combination.FactorCombiner.equal_weight",
_capture_equal_weight,
)
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: {
"ic_mean": 0.12,
"icir": 1.23,
@@ -272,19 +272,19 @@ def test_visualize_defaults_factor_specific_plots_to_split_top_factor(tmp_path,
quintile_paths: list[str] = []
monkeypatch.setattr(
"factorminer.cli._load_runtime_dataset_for_analysis",
"src.factorminer.factorminer.cli._load_runtime_dataset_for_analysis",
lambda cfg, data_path, mock: dataset,
)
monkeypatch.setattr(
"factorminer.cli._recompute_analysis_artifacts",
"src.factorminer.factorminer.cli._recompute_analysis_artifacts",
lambda library, dataset_arg, signal_failure_policy: artifacts,
)
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),
)
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),
)

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 pandas as pd
from factorminer.cli import _build_core_mining_config, _prepare_data_arrays, main
from factorminer.utils.config import load_config
from src.factorminer.factorminer.cli import _build_core_mining_config, _prepare_data_arrays, main
from src.factorminer.factorminer.utils.config import load_config
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 pytest
from factorminer.evaluation.combination import FactorCombiner
from factorminer.evaluation.selection import FactorSelector
from src.factorminer.factorminer.evaluation.combination import FactorCombiner
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 pytest
from 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.loader import load_market_data
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
from factorminer.agent.critic import CriticAgent
from factorminer.agent.debate import DebateConfig, DebateGenerator
from factorminer.agent.llm_interface import MockProvider
from factorminer.agent.output_parser import CandidateFactor
from factorminer.agent.prompt_builder import PromptBuilder
from factorminer.agent.specialists import (
from src.factorminer.factorminer.agent.critic import CriticAgent
from src.factorminer.factorminer.agent.debate import DebateConfig, DebateGenerator
from src.factorminer.factorminer.agent.llm_interface import MockProvider
from src.factorminer.factorminer.agent.output_parser import CandidateFactor
from src.factorminer.factorminer.agent.prompt_builder import PromptBuilder
from src.factorminer.factorminer.agent.specialists import (
SpecialistConfig,
SpecialistPromptBuilder,
)

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

@@ -5,7 +5,7 @@ from __future__ import annotations
import numpy as np
import pytest
from factorminer.evaluation.metrics import (
from src.factorminer.factorminer.evaluation.metrics import (
compute_factor_stats,
compute_ic,
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 pytest
from factorminer.core.parser import parse, try_parse, tokenize
from factorminer.core.expression_tree import (
from src.factorminer.factorminer.core.parser import parse, try_parse, tokenize
from src.factorminer.factorminer.core.expression_tree import (
ConstantNode,
ExpressionTree,
LeafNode,
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:
HAS_HELIX = False
from factorminer.agent.llm_interface import MockProvider
from factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.config import MiningConfig
from factorminer.core.ralph_loop import EvaluationResult
from src.factorminer.factorminer.agent.llm_interface import MockProvider
from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from src.factorminer.factorminer.core.config import MiningConfig
from src.factorminer.factorminer.core.ralph_loop import EvaluationResult
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
from factorminer.memory.knowledge_graph import (
from src.factorminer.factorminer.memory.knowledge_graph import (
EdgeType,
FactorKnowledgeGraph,
FactorNode,

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

@@ -5,7 +5,7 @@ from __future__ import annotations
import numpy as np
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
from factorminer.memory.experience_memory import ExperienceMemoryManager
from factorminer.memory.embeddings import FormulaEmbedder
from factorminer.memory.kg_retrieval import retrieve_memory_enhanced
from factorminer.memory.knowledge_graph import FactorKnowledgeGraph, FactorNode
from factorminer.memory.memory_store import (
from src.factorminer.factorminer.memory.experience_memory import ExperienceMemoryManager
from src.factorminer.factorminer.memory.embeddings import FormulaEmbedder
from src.factorminer.factorminer.memory.kg_retrieval import retrieve_memory_enhanced
from src.factorminer.factorminer.memory.knowledge_graph import FactorKnowledgeGraph, FactorNode
from src.factorminer.factorminer.memory.memory_store import (
ExperienceMemory,
ForbiddenDirection,
MiningState,
StrategicInsight,
SuccessPattern,
)
from factorminer.memory.formation import form_memory
from factorminer.memory.evolution import evolve_memory
from factorminer.memory.retrieval import retrieve_memory
from src.factorminer.factorminer.memory.formation import form_memory
from src.factorminer.factorminer.memory.evolution import evolve_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 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
from factorminer.agent.llm_interface import MockProvider
from factorminer.core.factor_library import Factor
from factorminer.core.library_io import load_library
from factorminer.core.config import MiningConfig
from factorminer.core.helix_loop import HelixLoop
from factorminer.core.ralph_loop import EvaluationResult
from factorminer.core.session import MiningSession
from src.factorminer.factorminer.agent.llm_interface import MockProvider
from src.factorminer.factorminer.core.factor_library import Factor
from src.factorminer.factorminer.core.library_io import load_library
from src.factorminer.factorminer.core.config import MiningConfig
from src.factorminer.factorminer.core.helix_loop import HelixLoop
from src.factorminer.factorminer.core.ralph_loop import EvaluationResult
from src.factorminer.factorminer.core.session import MiningSession
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 pytest
from factorminer.agent.llm_interface import MockProvider
from factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.ralph_loop import (
from src.factorminer.factorminer.agent.llm_interface import MockProvider
from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from src.factorminer.factorminer.core.ralph_loop import (
BudgetTracker,
EvaluationResult,
FactorGenerator,
@@ -33,7 +33,7 @@ from factorminer.core.ralph_loop import (
RalphLoop,
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 pytest
from factorminer.evaluation.regime import (
from src.factorminer.factorminer.evaluation.regime import (
MarketRegime,
RegimeAwareEvaluator,
RegimeConfig,

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

@@ -8,17 +8,17 @@ import numpy as np
import pandas as pd
import pytest
from factorminer.core.factor_library import Factor
from factorminer.data.tensor_builder import TargetSpec, compute_targets
from factorminer.evaluation.portfolio import PortfolioBacktester
from factorminer.evaluation.research import (
from src.factorminer.factorminer.core.factor_library import Factor
from src.factorminer.factorminer.data.tensor_builder import TargetSpec, compute_targets
from src.factorminer.factorminer.evaluation.portfolio import PortfolioBacktester
from src.factorminer.factorminer.evaluation.research import (
FactorGeometryDiagnostics,
build_score_vector,
passes_research_admission,
run_research_model_suite,
)
from factorminer.evaluation.runtime import DatasetSplit, EvaluationDataset, evaluate_factors
from factorminer.utils.config import load_config
from src.factorminer.factorminer.evaluation.runtime import DatasetSplit, EvaluationDataset, evaluate_factors
from src.factorminer.factorminer.utils.config import load_config
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 pytest
from factorminer.core.factor_library import Factor
from factorminer.core.parser import try_parse
from factorminer.evaluation.metrics import compute_factor_stats
from factorminer.evaluation.runtime import (
from src.factorminer.factorminer.core.factor_library import Factor
from src.factorminer.factorminer.core.parser import try_parse
from src.factorminer.factorminer.evaluation.metrics import compute_factor_stats
from src.factorminer.factorminer.evaluation.runtime import (
DatasetSplit,
EvaluationDataset,
SignalComputationError,

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

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

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

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

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

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

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

@@ -15,7 +15,7 @@ import numpy as np
import pandas as pd
from scipy.stats import rankdata
from factorminer.evaluation.metrics import (
from src.factorminer.factorminer.evaluation.metrics import (
compute_ic,
compute_icir,
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
np.random.seed(42)
from factorminer.data.mock_data import generate_mock_data, MockConfig
from factorminer.data.preprocessor import preprocess
from factorminer.core.parser import parse, try_parse
from factorminer.core.factor_library import Factor, FactorLibrary
from factorminer.core.library_io import PAPER_FACTORS
from factorminer.evaluation.metrics import (
from src.factorminer.factorminer.data.mock_data import generate_mock_data, MockConfig
from src.factorminer.factorminer.data.preprocessor import preprocess
from src.factorminer.factorminer.core.parser import parse, try_parse
from src.factorminer.factorminer.core.factor_library import Factor, FactorLibrary
from src.factorminer.factorminer.core.library_io import PAPER_FACTORS
from src.factorminer.factorminer.evaluation.metrics import (
compute_ic, compute_icir, compute_ic_mean, compute_ic_win_rate,
compute_factor_stats,
)
from factorminer.evaluation.combination import FactorCombiner
from factorminer.evaluation.selection import FactorSelector
from src.factorminer.factorminer.evaluation.combination import FactorCombiner
from src.factorminer.factorminer.evaluation.selection import FactorSelector
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__
_hb = _load_module_direct(
"factorminer.benchmark.helix_benchmark",
"src.factorminer.factorminer.benchmark.helix_benchmark",
_REPO_ROOT / "factorminer" / "benchmark" / "helix_benchmark.py",
)
_json_safe = _hb._json_safe

3636
src/factorminer/uv.lock generated
View File

File diff suppressed because it is too large Load Diff