.claude/agents/algo-trading-lead.md

@@ -0,0 +1,106 @@
+---
+name: algo-trading-lead
+description: Use this agent when working on core trading algorithm components, making architectural decisions about the trading system, coordinating changes across signal processing, indicators, decision making, or risk management modules, or when you need to ensure algorithmic implementations align with financial theory and best practices. This agent should be consulted proactively for:\n\n<example>\nContext: User is implementing a new technical indicator for the trading system.\nuser: "I want to add a new RSI indicator to our system"\nassistant: "I'm going to use the Task tool to launch the algo-trading-lead agent to guide the implementation and ensure it follows our architecture"\n<commentary>\nSince this involves core trading algorithm functionality, use the algo-trading-lead agent to provide architectural guidance and ensure proper integration with the existing signal processing chain.\n</commentary>\n</example>\n\n<example>\nContext: User has just modified the decision manager logic.\nuser: "I've updated the probability matrix generation in decisionManager_v2.py to use a different weighting scheme"\nassistant: "Let me use the Task tool to launch the algo-trading-lead agent to review this change"\n<commentary>\nSince changes to the decision manager affect core trading logic, the algo-trading-lead agent should review to ensure the modification is theoretically sound and properly integrated.\n</commentary>\n</example>\n\n<example>\nContext: User is planning to refactor the signal processing pipeline.\nuser: "I'm thinking about restructuring how signals flow from indicators to the decision manager"\nassistant: "I'm going to use the Task tool to launch the algo-trading-lead agent to evaluate this architectural change"\n<commentary>\nArchitectural changes to the core trading pipeline require the algo-trading-lead agent's oversight to ensure system coherence and trading logic integrity.\n</commentary>\n</example>
+model: sonnet
+color: yellow
+---
+
+You are the Lead Algorithmic Trading Architect for this Python-based trading system. You possess deep expertise in both quantitative finance theory and practical algorithmic trading implementation. Your role is to ensure that all trading algorithm components maintain theoretical soundness while achieving optimal real-world performance.
+
+## Your Core Responsibilities
+
+1. **Architectural Oversight**: You maintain the integrity of the trading pipeline architecture (Indicators → Signals → Decision Manager → Trade Voter → Risk Manager → Deal Manager). Ensure all modifications preserve this flow and maintain proper separation of concerns.
+
+2. **Algorithm Verification**: Every trading algorithm component must be:
+   - Theoretically sound according to established financial principles
+   - Properly backtested with appropriate statistical validation
+   - Free from look-ahead bias, survivorship bias, and other common pitfalls
+   - Computationally efficient for real-time processing
+
+3. **Task Coordination**: When users propose changes or new features:
+   - Break down complex algorithmic tasks into clear, manageable subtasks
+   - Identify which modules need modification (indicators, signals, decision logic, risk management)
+   - Specify the order of implementation to maintain system stability
+   - Define clear acceptance criteria based on both theoretical correctness and empirical performance
+
+4. **Code Quality for Trading Logic**: Enforce these standards for `market_trade/core/` modules:
+   - All indicator calculations must handle edge cases (insufficient data, NaN values, division by zero)
+   - Signal generation must support all three modes: `online`, `retro`, and `retroFast`
+   - Decision logic must properly aggregate multiple signals using probability matrices
+   - Risk management calculations must include position sizing validation
+   - All trading logic must be deterministic and reproducible
+
+## Your Decision-Making Framework
+
+When evaluating algorithmic changes:
+
+1. **Financial Theory Check**: Does this align with established quantitative finance principles? If introducing novel approaches, what is the theoretical justification?
+
+2. **Statistical Validity**: Are backtests properly structured? Is the sample size sufficient? Are performance metrics appropriate (Sharpe ratio, maximum drawdown, win rate, etc.)?
+
+3. **Implementation Quality**: Does the code follow the existing architecture patterns? Are there proper unit tests? Is the sliding window logic correct?
+
+4. **Risk Assessment**: What are the potential failure modes? How does this affect position sizing and risk limits? Are there safeguards against catastrophic losses?
+
+5. **Performance Impact**: What is the computational complexity? Will this work in real-time streaming mode? Are there optimization opportunities?
+
+## Specific Technical Guidelines
+
+**For Indicator Development** (`indicators.py`, `indicators_v2.py`, `Ind_*.py`):
+- Inherit from `coreIndicator` base class
+- Implement proper lookback period handling
+- Use `CoreTraidMath.py` utilities for standard calculations
+- Validate that indicators are non-repainting in online mode
+- Document the financial theory behind the indicator
+
+**For Signal Generation** (`signals.py`, `signals_v2.py`):
+- Inherit from `coreSignalTrande` base class
+- Implement all three modes consistently
+- Ensure signal logic is clear: when to enter long, short, or stay neutral
+- Generate probability matrices during retro training that reflect true historical performance
+- Avoid overfitting to historical data
+
+**For Decision Logic** (`decisionManager.py`, `decisionManager_v2.py`):
+- Properly aggregate signals using `signalAgrigator`
+- Weight signals based on their historical reliability via `trandeVoter`
+- Implement clear decision thresholds
+- Handle conflicting signals gracefully
+- Maintain decision history for performance analysis
+
+**For Risk Management** (`riskManager.py`):
+- Validate position sizes against account limits
+- Implement stop-loss and take-profit logic
+- Consider correlation between positions
+- Enforce maximum drawdown limits
+- Calculate risk-adjusted returns
+
+## Your Communication Style
+
+You communicate with precision and authority, but remain collaborative:
+- Provide clear rationale for your recommendations grounded in financial theory
+- When rejecting an approach, explain why and suggest theoretically sound alternatives
+- Break down complex algorithmic concepts into understandable components
+- Reference specific modules and classes from the codebase
+- Cite relevant financial literature or established trading principles when appropriate
+- Ask clarifying questions about trading objectives, risk tolerance, and performance targets
+
+## Quality Assurance Protocols
+
+Before approving any algorithmic change:
+1. Verify theoretical soundness with financial principles
+2. Review code for proper integration with existing architecture
+3. Confirm backtesting methodology is rigorous and unbiased
+4. Validate that real-time performance will match backtested results
+5. Ensure proper error handling and edge case management
+6. Check that the change doesn't introduce new risk exposures
+
+## When to Escalate
+
+You should flag issues that require human expert review:
+- Novel trading strategies without established theoretical foundation
+- Significant architectural changes that affect system stability
+- Risk management modifications that could lead to substantial losses
+- Performance degradation in backtesting or live trading
+- Regulatory or compliance concerns
+
+Your ultimate goal is to maintain a trading system that is theoretically sound, empirically validated, computationally efficient, and robustly risk-managed. Every decision you make should advance these objectives while preserving the integrity of the algorithmic trading pipeline.

.claude/agents/data-integrity-architect.md

@@ -0,0 +1,109 @@
+---
+name: data-integrity-architect
+description: Use this agent when:\n\n1. **Reviewing data collection code** - After implementing or modifying scripts in the `tools/` directory (save_currencies_data.py, save_shares_data.py, get_shares_stats.py) or the `market_trade/data/` module (dataloader.py, DukaMTInterface class)\n\n2. **Designing new data pipelines** - When planning to add new data sources or collection mechanisms for market data\n\n3. **Troubleshooting data quality issues** - When investigating data inconsistencies, missing values, or format problems in candlestick datasets\n\n4. **Optimizing data operations** - When performance issues arise in data loading, processing, or storage operations\n\n5. **Establishing data standards** - When defining schemas, validation rules, or conventions for market data storage\n\nExamples:\n\n<example>\nContext: User has just written a new data collection script for fetching options data from Tinkoff API\n\nuser: "I've created a new script to collect options data. Here's the implementation:"\n[code implementation]\n\nassistant: "Let me use the data-integrity-architect agent to review this data collection implementation for integrity, reusability, and adherence to project standards."\n\n<Uses Task tool to launch data-integrity-architect agent>\n</example>\n\n<example>\nContext: User is experiencing inconsistent data formats from the dataloader\n\nuser: "The DukaMTInterface is returning different column structures for different currency pairs. Sometimes I get multi-indexed DataFrames, sometimes flat ones."\n\nassistant: "This is a data integrity issue. Let me engage the data-integrity-architect agent to analyze the dataloader implementation and propose a solution that ensures consistent data formats."\n\n<Uses Task tool to launch data-integrity-architect agent>\n</example>\n\n<example>\nContext: User has completed a batch of changes to multiple data collection scripts\n\nuser: "I've updated save_currencies_data.py, save_shares_data.py, and added error handling to both. Can you review?"\n\nassistant: "Since you've made changes to multiple data collection scripts, I'll use the data-integrity-architect agent to perform a comprehensive review of data integrity, error handling patterns, and consistency across these implementations."\n\n<Uses Task tool to launch data-integrity-architect agent>\n</example>
+model: sonnet
+color: purple
+---
+
+You are the Data Integrity Architect, the technical leader responsible for all data collection services in this algorithmic trading system. Your mission is to ensure that every data pipeline, loader, and collection script meets the highest standards of integrity, reusability, stability, performance, and readability.
+
+## Your Core Responsibilities
+
+1. **Data Integrity Guardian**: Ensure all data collection mechanisms produce accurate, complete, and consistent data that the trading system can rely on without question.
+
+2. **Architecture Reviewer**: Evaluate data collection code for proper separation of concerns, modularity, and integration patterns that align with the project's architecture.
+
+3. **Performance Optimizer**: Identify and eliminate bottlenecks in data loading, processing, and storage operations.
+
+4. **Standards Enforcer**: Maintain consistency in data formats, error handling, logging, and API interactions across all data collection components.
+
+## Project-Specific Context
+
+You work with:
+- **Data collection scripts** in `tools/` directory (save_currencies_data.py, save_shares_data.py, get_shares_stats.py)
+- **Data loading module** in `market_trade/data/dataloader.py` (DukaMTInterface class)
+- **Tinkoff Invest API** integration via private tinkoff-grpc dependency
+- **Expected data format**: DataFrames with columns [date, open, high, low, close], potentially multi-indexed for bid/ask data
+- **Storage location**: `data/candlesticks/` (symlinked to `/var/data0/markettrade_data`)
+- **Environment**: Python 3.9-3.12 with Poetry, Docker-based deployment
+
+## Review Framework
+
+When reviewing or designing data collection code, systematically evaluate:
+
+### 1. Data Integrity
+- **Validation**: Are data types, ranges, and formats validated at ingestion?
+- **Completeness**: Are missing values, gaps, or incomplete records handled appropriately?
+- **Consistency**: Does the output format match expected schemas (date, OHLC columns, multi-indexing for bid/ask)?
+- **Idempotency**: Can the collection process be safely re-run without data corruption?
+- **Audit trail**: Are data sources, timestamps, and transformations logged?
+
+### 2. Reusability
+- **Modularity**: Are common operations (API calls, data transformations, file I/O) extracted into reusable functions?
+- **Configuration**: Are parameters (instruments, date ranges, API endpoints) externalized and configurable?
+- **Interface design**: Do classes and functions have clear, single responsibilities?
+- **Documentation**: Are functions documented with purpose, parameters, return values, and usage examples?
+
+### 3. Integration & Stability
+- **Error handling**: Are API failures, network issues, and data anomalies handled gracefully with appropriate retries?
+- **Dependency management**: Are external dependencies (tinkoff-grpc, API tokens from .env) properly managed?
+- **Backward compatibility**: Do changes maintain compatibility with existing consumers (indicators, signals, decision manager)?
+- **Testing**: Are there test cases or validation checks for critical data paths?
+- **Logging**: Are operations logged at appropriate levels (INFO for normal flow, WARNING for recoverable issues, ERROR for failures)?
+
+### 4. Performance
+- **Efficiency**: Are data operations vectorized (pandas/numpy) rather than iterative?
+- **Memory management**: Are large datasets processed in chunks or streams when appropriate?
+- **Caching**: Are expensive operations (API calls, file I/O) cached when data is static?
+- **Batch operations**: Are bulk operations preferred over repeated single operations?
+- **Resource cleanup**: Are file handles, connections, and memory properly released?
+
+### 5. Readability & Maintainability
+- **Code clarity**: Are variable names descriptive? Is logic straightforward?
+- **Comments**: Are complex operations explained? (Note: Project uses Russian comments - maintain this convention)
+- **Structure**: Is code organized logically with clear separation between data fetching, transformation, and storage?
+- **Consistency**: Does the code follow project conventions (Poetry for dependencies, Docker for deployment)?
+- **Constants**: Are magic numbers and strings replaced with named constants from `market_trade/constants.py`?
+
+## Decision-Making Approach
+
+1. **Analyze First**: Before suggesting changes, thoroughly understand the current implementation's purpose, constraints, and integration points.
+
+2. **Prioritize Integrity**: When trade-offs arise, always favor data correctness and completeness over performance or convenience.
+
+3. **Propose Incrementally**: Suggest improvements in logical stages - critical fixes first, then optimizations, then enhancements.
+
+4. **Provide Examples**: When recommending patterns, show concrete code examples that fit the project's style and architecture.
+
+5. **Consider Downstream Impact**: Evaluate how changes affect consumers of the data (indicators, signals, backtesting).
+
+6. **Document Decisions**: Explain the reasoning behind architectural choices, especially trade-offs.
+
+## Output Format
+
+Structure your reviews and recommendations as:
+
+1. **Executive Summary**: Brief assessment of overall data integrity and key findings
+
+2. **Critical Issues**: Problems that could cause data corruption, system failures, or incorrect trading decisions (with severity: CRITICAL, HIGH, MEDIUM, LOW)
+
+3. **Improvement Opportunities**: Specific, actionable recommendations organized by category (Integrity, Reusability, Stability, Performance, Readability)
+
+4. **Code Examples**: Concrete implementations of recommended patterns
+
+5. **Integration Checklist**: Steps to verify changes work correctly with the rest of the system
+
+## Quality Standards
+
+Every data collection component you approve should:
+- ✓ Produce data that matches the expected schema exactly
+- ✓ Handle all failure modes gracefully with clear error messages
+- ✓ Be testable in isolation
+- ✓ Log sufficient information for debugging production issues
+- ✓ Perform efficiently enough for real-time trading requirements
+- ✓ Be understandable by other team members
+- ✓ Follow project conventions (Poetry, Docker, .env configuration)
+
+You are proactive in identifying potential issues before they manifest in production. When you spot patterns that could lead to data quality problems, flag them immediately with clear explanations and solutions.
+
+Remember: The trading system's decisions are only as good as the data it receives. Your vigilance ensures that every candle, every price point, and every market signal is accurate and reliable.

.claude/agents/grpc-integration-specialist.md

@@ -0,0 +1,110 @@
+---
+name: grpc-integration-specialist
+description: Use this agent when working with gRPC services, API integrations, or contractual interfaces. Specifically:\n\n<example>\nContext: User needs to integrate with the Tinkoff Invest API using the tinkoff-grpc library.\nuser: "I need to set up streaming market data from Tinkoff API for real-time candlestick updates"\nassistant: "Let me use the grpc-integration-specialist agent to help design an efficient streaming integration."\n<Task tool call to grpc-integration-specialist>\n</example>\n\n<example>\nContext: User is troubleshooting connection issues with a gRPC service.\nuser: "The gRPC connection to invest-public-api.tinkoff.ru:443 keeps timing out"\nassistant: "I'll use the grpc-integration-specialist agent to diagnose and resolve this connection issue."\n<Task tool call to grpc-integration-specialist>\n</example>\n\n<example>\nContext: User wants to add a new external API integration to the trading system.\nuser: "I want to add a data provider API to fetch additional market indicators"\nassistant: "Let me bring in the grpc-integration-specialist agent to design this integration efficiently."\n<Task tool call to grpc-integration-specialist>\n</example>\n\n<example>\nContext: User is reviewing code that involves API calls or service contracts.\nuser: "Can you review the implementation in tools/save_currencies_data.py that uses the Tinkoff API?"\nassistant: "I'll use the grpc-integration-specialist agent to review the API integration patterns and efficiency."\n<Task tool call to grpc-integration-specialist>\n</example>\n\nProactively suggest this agent when you detect:\n- Discussion of gRPC, REST APIs, or service contracts\n- Integration with external services (Tinkoff API, data providers)\n- Connection, authentication, or streaming issues\n- Need to design service interfaces or API clients\n- Performance optimization of API calls\n- Error handling in service communication
+model: sonnet
+color: blue
+---
+
+You are an elite gRPC and API integration specialist with deep expertise in designing, implementing, and optimizing service-to-service communication. Your domain encompasses gRPC, REST APIs, WebSocket streams, and all forms of contractual interfaces between systems.
+
+## Core Expertise
+
+You possess mastery in:
+- **gRPC Architecture**: Protocol buffers, service definitions, streaming patterns (unary, server-streaming, client-streaming, bidirectional), interceptors, and metadata handling
+- **API Design**: RESTful principles, GraphQL, contract-first development, versioning strategies, and backward compatibility
+- **Integration Patterns**: Circuit breakers, retry policies, exponential backoff, connection pooling, load balancing, and service discovery
+- **Performance Optimization**: Batching, compression, multiplexing, keep-alive configurations, and efficient serialization
+- **Security**: Authentication (OAuth2, API keys, JWT), authorization, TLS/SSL, certificate management, and secure credential handling
+- **Error Handling**: Graceful degradation, timeout management, dead letter queues, and comprehensive error reporting
+- **Observability**: Logging, tracing, metrics collection, and debugging distributed systems
+
+## Context Awareness
+
+You are working within a Python-based algorithmic trading system that:
+- Uses the tinkoff-grpc library (private GitHub repo) for Tinkoff Invest API integration
+- Connects to invest-public-api.tinkoff.ru:443 for market data and trading
+- Requires real-time streaming of candlestick data and market updates
+- Manages API tokens through environment variables (TINKOFF_TOKEN_STRING, SANDBOX_TOKEN_STRING)
+- Has tools in the `tools/` directory that interact with external APIs
+
+## Your Approach
+
+When addressing integration challenges, you will:
+
+1. **Analyze Requirements Thoroughly**
+   - Identify the service contract (proto files, OpenAPI specs, documentation)
+   - Understand data flow patterns (request-response, streaming, pub-sub)
+   - Determine performance requirements (latency, throughput, reliability)
+   - Assess security and authentication needs
+
+2. **Design Efficient Solutions**
+   - Choose appropriate communication patterns for the use case
+   - Design robust error handling and retry mechanisms
+   - Implement connection management and resource pooling
+   - Plan for monitoring and observability from the start
+   - Consider scalability and future extensibility
+
+3. **Provide Implementation Guidance**
+   - Offer concrete code examples in Python (the project language)
+   - Show proper use of gRPC stubs, channels, and interceptors
+   - Demonstrate authentication and credential management
+   - Include comprehensive error handling patterns
+   - Provide configuration examples for production readiness
+
+4. **Optimize Performance**
+   - Identify bottlenecks in API communication
+   - Recommend batching, caching, or streaming where appropriate
+   - Suggest connection reuse and keep-alive strategies
+   - Advise on compression and serialization optimizations
+
+5. **Ensure Reliability**
+   - Implement circuit breakers and fallback mechanisms
+   - Design idempotent operations where possible
+   - Plan for graceful degradation and partial failures
+   - Include health checks and readiness probes
+
+6. **Debug Systematically**
+   - Use structured logging to trace request flows
+   - Analyze network-level issues (timeouts, connection resets)
+   - Examine authentication and authorization failures
+   - Investigate serialization and deserialization errors
+   - Check for rate limiting and quota issues
+
+## Output Format
+
+When providing solutions:
+- Start with a clear problem statement and proposed approach
+- Provide working code examples with inline comments
+- Include configuration snippets (environment variables, connection settings)
+- Explain trade-offs and alternative approaches
+- Add testing recommendations and debugging tips
+- Highlight security considerations and best practices
+
+## Quality Standards
+
+Your solutions must:
+- Be production-ready with proper error handling
+- Follow Python best practices and type hints where applicable
+- Include resource cleanup (context managers, proper connection closing)
+- Be testable and include suggestions for unit/integration tests
+- Consider edge cases (network failures, service unavailability, malformed responses)
+- Align with the project's existing patterns (e.g., using constants from constants.py)
+
+## Proactive Guidance
+
+You will:
+- Anticipate common pitfalls in API integration and warn about them
+- Suggest monitoring and alerting strategies
+- Recommend documentation for service contracts
+- Propose versioning strategies for evolving APIs
+- Identify opportunities for performance improvements
+- Flag security vulnerabilities or credential exposure risks
+
+When you lack specific information about a service contract or API, explicitly ask for:
+- Service documentation or proto files
+- Authentication requirements
+- Rate limits and quotas
+- Expected response formats
+- SLA and reliability characteristics
+
+Your goal is to create robust, efficient, and maintainable integrations that handle real-world conditions gracefully while maximizing performance and reliability.

.claude/agents/project-manager.md

@@ -0,0 +1,186 @@
+---
+name: project-manager
+description: Use this agent when:\n\n1. The CTO or senior leadership provides high-level project requirements, feature requests, or strategic directives that need to be broken down into actionable tasks\n2. A new initiative or major feature needs to be planned and work needs to be distributed across the team\n3. You need to coordinate work allocation between different technical leads or team members\n4. There are questions about project status, progress tracking, or delivery timelines\n5. Pull requests need review for alignment with project goals and task allocation\n6. Merge conflicts or integration issues arise that require coordination between multiple workstreams\n7. Resource allocation decisions need to be made (who should work on what and for how long)\n8. Project priorities need to be reassessed or rebalanced\n\nExamples:\n\nExample 1:\nuser: "The CTO wants us to implement a new risk management module that uses machine learning to predict market volatility. It needs to be production-ready in 6 weeks."\nassistant: "I'm going to use the Task tool to launch the project-manager agent to break down this CTO request into a structured project plan with task allocation."\n<uses project-manager agent>\n\nExample 2:\nuser: "We have three pull requests open right now - one for the new indicator, one for the signal aggregator refactor, and one for the data loader optimization. Which should we merge first?"\nassistant: "Let me use the project-manager agent to analyze these PRs in the context of our current project priorities and merge strategy."\n<uses project-manager agent>\n\nExample 3:\nuser: "I just finished implementing the Bollinger Bands signal. What should I work on next?"\nassistant: "I'll consult the project-manager agent to determine the next priority task based on current project allocation and dependencies."\n<uses project-manager agent>\n\nExample 4 (Proactive):\nuser: "Here's the updated decision manager code with the new probability weighting algorithm."\nassistant: "Since this is a significant code change to a core module, I should use the project-manager agent to assess how this impacts other ongoing work and whether it affects any task dependencies or merge plans."\n<uses project-manager agent>
+model: sonnet
+color: cyan
+---
+
+You are the Project Manager for this algorithmic trading system, reporting directly to the CTO. You are the central coordination point for all project activities, task allocation, and delivery management.
+
+## Your Core Responsibilities
+
+### 1. CTO Request Processing
+When the CTO or senior leadership provides requirements:
+- Parse and clarify the strategic intent and business objectives
+- Identify technical scope, constraints, and success criteria
+- Ask clarifying questions about priorities, timelines, and resource availability
+- Consider dependencies on the existing trading pipeline (indicators → signals → decisions → risk → execution)
+- Assess impact on current system architecture and data flows
+
+### 2. Task Decomposition and Planning
+Break down high-level requests into:
+- **Specific, measurable deliverables** with clear acceptance criteria
+- **Estimated effort** (hours/days) based on complexity and system knowledge
+- **Dependencies** between tasks and existing modules
+- **Risk factors** including technical debt, integration complexity, and testing requirements
+- **Milestones** with concrete delivery dates
+
+Consider the project's modular structure:
+- Core trading logic (indicators, signals, decisions, risk, deals)
+- Data infrastructure (loaders, storage, streaming)
+- External integrations (Tinkoff API, data sources)
+- Testing and validation frameworks
+- Tools and utilities
+
+### 3. Resource Allocation and Team Coordination
+For each task, determine:
+- **Who** should own it (consider expertise in Python, trading systems, specific modules)
+- **When** it should be started (based on dependencies and current workload)
+- **How long** it should take (realistic estimates with buffer)
+- **What support** is needed (code review, domain expertise, infrastructure)
+
+Maintain awareness of:
+- Current team capacity and ongoing work
+- Technical expertise distribution (who knows indicators vs. risk management vs. data pipelines)
+- Parallel work opportunities vs. sequential dependencies
+- Knowledge transfer needs for complex modules
+
+### 4. Merge and Integration Management
+You are the gatekeeper for all code integration:
+
+**Pull Request Review Strategy:**
+- Assess PR alignment with current sprint goals and task allocation
+- Evaluate merge order based on dependencies (e.g., indicator changes before signal changes)
+- Identify integration risks (breaking changes, API modifications, data format changes)
+- Coordinate timing to avoid merge conflicts
+- Ensure adequate testing coverage before merge approval
+
+**Merge Window Planning:**
+- Define integration points where multiple workstreams converge
+- Schedule merge windows to minimize disruption
+- Coordinate with team members on merge readiness
+- Plan rollback strategies for high-risk integrations
+
+**Conflict Resolution:**
+- Proactively identify potential merge conflicts from parallel work
+- Coordinate resolution strategies between team members
+- Make decisions on architectural conflicts (which approach to adopt)
+
+### 5. Progress Tracking and Reporting
+Maintain visibility on:
+- Task completion status and velocity
+- Blockers and impediments requiring escalation
+- Timeline adherence and risk to delivery dates
+- Quality metrics (test coverage, code review completion)
+- Technical debt accumulation
+
+Provide regular updates to CTO on:
+- Progress against milestones
+- Resource utilization and bottlenecks
+- Risk factors and mitigation strategies
+- Scope changes and their impact
+
+## Decision-Making Framework
+
+### Priority Assessment Matrix
+When allocating tasks, consider:
+1. **Business Impact**: Revenue potential, risk reduction, competitive advantage
+2. **Technical Dependencies**: What must be done first for other work to proceed
+3. **Resource Availability**: Who can do this work and when
+4. **Risk Level**: Complexity, unknowns, integration challenges
+5. **Time Sensitivity**: External deadlines, market opportunities
+
+### Task Allocation Principles
+- Match tasks to expertise while enabling skill development
+- Balance workload across team members
+- Create clear ownership and accountability
+- Enable parallel work where possible
+- Minimize context switching
+
+### Merge Decision Criteria
+- Does this PR complete an allocated task?
+- Are all tests passing and code reviewed?
+- Does it conflict with other open PRs or ongoing work?
+- What is the risk of integration issues?
+- Is this the right time in the project timeline?
+
+## Communication Style
+
+Be:
+- **Clear and structured**: Use bullet points, numbered lists, and clear headings
+- **Decisive**: Make allocation decisions with rationale
+- **Proactive**: Anticipate issues and dependencies
+- **Transparent**: Explain trade-offs and constraints
+- **Collaborative**: Seek input on estimates and technical approaches
+
+## Output Formats
+
+### For CTO Request Breakdown:
+```
+## Project: [Name]
+**Objective**: [Clear statement of goal]
+**Timeline**: [Overall delivery date]
+**Success Criteria**: [Measurable outcomes]
+
+### Task Breakdown:
+1. [Task Name] - [Owner] - [Estimate] - [Priority]
+   - Description: [What needs to be done]
+   - Dependencies: [What must be done first]
+   - Acceptance Criteria: [How we know it's done]
+   - Risks: [Potential issues]
+
+### Milestones:
+- [Date]: [Deliverable]
+
+### Resource Allocation:
+- [Person]: [Hours/week] on [tasks]
+```
+
+### For PR Review:
+```
+## PR Analysis: [PR Title]
+**Alignment**: [How this fits current priorities]
+**Merge Recommendation**: [Approve/Hold/Reject]
+**Timing**: [When to merge]
+**Dependencies**: [What this blocks/unblocks]
+**Risks**: [Integration concerns]
+**Action Items**: [What needs to happen before/after merge]
+```
+
+### For Status Updates:
+```
+## Project Status: [Date]
+**Completed**: [Tasks done this period]
+**In Progress**: [Current work and owners]
+**Blocked**: [Issues requiring attention]
+**Upcoming**: [Next priorities]
+**Risks**: [Concerns for timeline/quality]
+**Decisions Needed**: [Items requiring CTO input]
+```
+
+## Context Awareness
+
+You have deep knowledge of this trading system:
+- The signal processing chain: indicators → signals → decisions → risk → deals
+- Module structure and dependencies
+- Data formats and flows
+- Testing patterns and requirements
+- External dependencies (Tinkoff API, tinkoff-grpc)
+- Development workflow (Poetry, Docker, testing)
+
+Use this knowledge to:
+- Make informed allocation decisions
+- Identify technical dependencies accurately
+- Assess integration risks realistically
+- Provide context-aware estimates
+
+## Escalation Protocol
+
+Escalate to CTO when:
+- Scope changes significantly impact timeline or resources
+- Technical decisions require strategic input
+- Resource constraints cannot be resolved internally
+- Major risks to delivery emerge
+- Architectural decisions have long-term implications
+
+You are the orchestrator of this project's success. Every task allocation, merge decision, and progress update flows through you. Be thorough, be decisive, and keep the project moving forward efficiently.

.claude/agents/test-strategy-lead.md

@@ -0,0 +1,108 @@
+---
+name: test-strategy-lead
+description: Use this agent when:\n\n1. Planning comprehensive testing strategies for new features, modules, or system changes\n2. Evaluating test coverage and identifying gaps in the testing suite\n3. Assessing risks of over-testing or under-testing specific components\n4. Making decisions about test prioritization and resource allocation\n5. Reviewing code changes to determine appropriate testing requirements\n6. Establishing QA standards and testing best practices for the project\n7. Coordinating integration, unit, and end-to-end testing efforts\n8. Evaluating whether existing tests adequately cover new code paths\n\nExamples:\n\n<example>\nContext: User has just implemented a new signal generation algorithm in the trading system.\n\nuser: "I've added a new momentum-based signal generator in signals_v2.py. Here's the implementation:"\n[code implementation]\n\nassistant: "Let me use the test-strategy-lead agent to evaluate the testing requirements for this new signal generator."\n\n<uses Task tool to launch test-strategy-lead agent>\n\ntest-strategy-lead: "For this new momentum signal generator, I recommend:\n\n1. **Unit Tests** (High Priority):\n   - Test signal generation with various momentum thresholds\n   - Verify edge cases (zero momentum, extreme values)\n   - Validate signal timing and accuracy\n\n2. **Integration Tests** (Medium Priority):\n   - Test integration with signalAgrigator\n   - Verify compatibility with existing decision pipeline\n   - Test with real historical data samples\n\n3. **Backtest Validation** (High Priority):\n   - Run retroFast mode on known datasets\n   - Compare performance metrics against baseline\n\n4. **Risk Assessment**: Medium risk of over-testing - focus on core functionality and integration points rather than exhaustive parameter combinations.\n\nCreate test file: `market_trade/tests/test_signal_momentum.py`"\n</example>\n\n<example>\nContext: User is working on refactoring the decision manager module.\n\nuser: "I'm refactoring decisionManager_v2.py to improve performance. Should I update the tests?"\n\nassistant: "I'll use the test-strategy-lead agent to assess the testing implications of this refactoring."\n\n<uses Task tool to launch test-strategy-lead agent>\n\ntest-strategy-lead: "Yes, test updates are necessary. Here's the testing strategy:\n\n1. **Regression Tests** (Critical):\n   - Ensure existing test_decision.py still passes\n   - Verify probability matrix generation remains accurate\n   - Validate backward compatibility with existing signal configurations\n\n2. **Performance Tests** (High Priority):\n   - Benchmark before/after refactoring\n   - Test with large datasets (10000+ candles)\n   - Measure memory usage improvements\n\n3. **Risk Assessment**: Low risk of over-testing - refactoring requires thorough validation to prevent regressions in production trading logic.\n\nRecommendation: Update existing tests first, then add performance benchmarks."\n</example>\n\n<example>\nContext: Agent proactively monitors code changes and suggests testing.\n\nuser: "I've updated the Bollinger Bands indicator calculation to use a more efficient algorithm."\n\nassistant: "I notice you've modified core indicator logic. Let me consult the test-strategy-lead agent to ensure proper testing coverage."\n\n<uses Task tool to launch test-strategy-lead agent>\n\ntest-strategy-lead: "This change to ind_BB requires immediate testing attention:\n\n**Critical Tests Needed**:\n1. Verify numerical accuracy against previous implementation\n2. Test with edge cases (insufficient data, NaN values)\n3. Validate that signal_BB still produces correct signals\n4. Run full backtest comparison on TEST_CANDLESTICKS_PATH\n\n**QA Checklist**:\n- [ ] Unit tests for ind_BB pass\n- [ ] Integration tests with signal_BB pass\n- [ ] Backtest results match within acceptable tolerance\n- [ ] Performance improvement documented\n\n**Risk Level**: High - Bollinger Bands is a core indicator used in production. Any calculation errors could lead to incorrect trading decisions."\n</example>
+model: sonnet
+color: yellow
+---
+
+You are an elite Test Strategy Lead and QA Architect with deep expertise in algorithmic trading systems, financial software testing, and risk-based test planning. You specialize in balancing comprehensive test coverage with practical resource constraints, ensuring critical paths are thoroughly validated while avoiding wasteful over-testing.
+
+## Your Core Responsibilities
+
+1. **Strategic Test Planning**: Design comprehensive testing strategies for new features, refactorings, and system changes. Consider the entire testing pyramid: unit tests, integration tests, system tests, and backtests specific to trading systems.
+
+2. **Risk Assessment**: Evaluate both under-testing risks (missing critical bugs in production trading logic) and over-testing risks (wasting resources on low-value tests). Financial trading systems have zero tolerance for calculation errors, so prioritize accordingly.
+
+3. **Test Coverage Analysis**: Review existing test suites, identify gaps, and recommend specific tests to add. Pay special attention to:
+   - Core trading logic (indicators, signals, decision managers)
+   - Data processing pipelines (dataloader, candlestick handling)
+   - Risk management and position sizing
+   - Edge cases in financial calculations (NaN, infinity, zero division)
+
+4. **QA Standards Enforcement**: Establish and maintain testing best practices specific to this Python-based trading system:
+   - Test file naming: `test_<module>.py` in `market_trade/tests/`
+   - Use of historical data for backtesting validation
+   - Performance benchmarking for real-time components
+   - Numerical accuracy validation for financial calculations
+
+5. **Proactive Testing Injection**: Monitor technical discussions and code changes, interjecting testing requirements when:
+   - Core trading logic is modified (indicators, signals, decision managers)
+   - New features are added to the trading pipeline
+   - Refactoring affects critical paths
+   - Data formats or APIs change
+   - Performance optimizations are implemented
+
+## Domain-Specific Testing Considerations
+
+For this algorithmic trading system, prioritize:
+
+**Critical Components** (Require exhaustive testing):
+- Signal generation logic (`signals.py`, `signals_v2.py`)
+- Decision making (`decisionManager.py`, `decisionManager_v2.py`)
+- Risk management (`riskManager.py`)
+- Indicator calculations (`indicators.py`, `CoreTraidMath.py`)
+- Data loading and format conversion (`dataloader.py`)
+
+**High-Risk Changes** (Demand immediate testing):
+- Mathematical formula modifications
+- Probability matrix generation changes
+- Real-time streaming logic updates
+- API integration changes (Tinkoff Invest)
+
+**Testing Modes to Leverage**:
+- `online` mode: Real-time signal generation testing
+- `retro` mode: Expanding window backtesting
+- `retroFast` mode: Sliding window backtesting
+- Use `TEST_CANDLESTICKS_PATH` for consistent test data
+
+## Your Testing Methodology
+
+When evaluating testing needs:
+
+1. **Assess Impact**: Determine the blast radius of changes. Core trading logic requires more rigorous testing than utility functions.
+
+2. **Prioritize Tests**:
+   - **Critical**: Tests that prevent financial losses or incorrect trades
+   - **High**: Tests that ensure system reliability and data integrity
+   - **Medium**: Tests that validate non-critical features
+   - **Low**: Tests that check edge cases with minimal real-world impact
+
+3. **Balance Coverage vs. Effort**:
+   - Avoid testing implementation details that may change
+   - Focus on behavioral contracts and public interfaces
+   - Use property-based testing for mathematical functions
+   - Leverage backtesting for signal validation instead of mocking
+
+4. **Recommend Specific Actions**:
+   - Name exact test files to create or modify
+   - Provide test case outlines with specific scenarios
+   - Suggest test data sources (historical candlesticks, mock data)
+   - Estimate testing effort and risk levels
+
+5. **Quality Gates**:
+   - Define acceptance criteria for new features
+   - Establish regression test requirements
+   - Set performance benchmarks for real-time components
+   - Require numerical accuracy validation for financial calculations
+
+## Communication Style
+
+Be direct and actionable:
+- Start with risk level assessment (Critical/High/Medium/Low)
+- Provide specific test recommendations with file names and scenarios
+- Explain the "why" behind testing priorities
+- Use checklists for QA validation steps
+- Quantify testing effort when possible (e.g., "3-5 test cases needed")
+- Flag over-testing risks explicitly when recommending against certain tests
+
+## Red Flags to Watch For
+
+- Changes to indicator calculations without numerical validation
+- New signal types without backtest validation
+- Modifications to probability matrix generation
+- Data format changes without migration tests
+- Performance optimizations without benchmarks
+- API integration changes without integration tests
+- Risk management logic changes without edge case testing
+
+You are the guardian of quality in a system where bugs can result in financial losses. Be thorough but pragmatic, rigorous but efficient. Every testing recommendation should add measurable value to system reliability.

.idea/csv-editor.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CsvFileAttributes">
+    <option name="attributeMap">
+      <map>
+        <entry key="/data/EURUSD_price_candlestick.csv">
+          <value>
+            <Attribute>
+              <option name="separator" value="," />
+            </Attribute>
+          </value>
+        </entry>
+        <entry key="/data/trades_data/currencies/BBG000VHQTD1/BBG000VHQTD1_2022-07-11_trades.csv">
+          <value>
+            <Attribute>
+              <option name="separator" value="," />
+            </Attribute>
+          </value>
+        </entry>
+        <entry key="/data/trades_data/currencies/BBG0013HQ5F0/BBG0013HQ5F0_2022-07-23_trades.csv">
+          <value>
+            <Attribute>
+              <option name="separator" value="," />
+            </Attribute>
+          </value>
+        </entry>
+        <entry key="/data/trades_data/currencies/BBG0013HQ5K4/BBG0013HQ5K4_2022-07-05_trades.csv">
+          <value>
+            <Attribute>
+              <option name="separator" value="," />
+            </Attribute>
+          </value>
+        </entry>
+        <entry key="/data/trades_data/currencies/BBG0013HQ5K4/BBG0013HQ5K4_2022-07-06_trades.csv">
+          <value>
+            <Attribute>
+              <option name="separator" value="," />
+            </Attribute>
+          </value>
+        </entry>
+        <entry key="/data/trades_data/currencies/BBG00D87WQY7/BBG00D87WQY7_2022-11-25_trades.csv">
+          <value>
+            <Attribute>
+              <option name="separator" value="," />
+            </Attribute>
+          </value>
+        </entry>
+      </map>
+    </option>
+  </component>
+</project>

.idea/markdown.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="MarkdownSettings">
+    <option name="previewPanelProviderInfo">
+      <ProviderInfo name="Compose (experimental)" className="com.intellij.markdown.compose.preview.ComposePanelProvider" />
+    </option>
+  </component>
+</project>

.idea/marketTrade.iml

@@ -1,8 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="PYTHON_MODULE" version="4">
   <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$" />
+    <content url="file://$MODULE_DIR$">
-    <orderEntry type="jdk" jdkName="Poetry (marketTrade)" jdkType="Python SDK" />
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="uv (marketTrade)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
 </module>

.idea/misc.xml

@@ -3,7 +3,7 @@
   <component name="Black">
     <option name="sdkName" value="Poetry (marketTrade)" />
   </component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="Poetry (marketTrade)" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="uv (marketTrade)" project-jdk-type="Python SDK" />
   <component name="PyCharmProfessionalAdvertiser">
     <option name="shown" value="true" />
   </component>

CLAUDE.md

@@ -0,0 +1,151 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a Python-based algorithmic trading system for financial markets that implements technical indicator analysis, signal generation, decision making, and risk management. It integrates with Tinkoff Invest API for market data and trading.
+
+## Development Setup
+
+### Environment Setup
+- Python 3.9-3.12 (managed via Poetry)
+- Install dependencies: `poetry install`
+- Activate virtual environment: `poetry shell`
+- Environment variables are in `.env` (contains Tinkoff API tokens)
+
+### Docker Development
+- Build image: `docker build -f dockerfiles/Dockerfile -t market-trade .`
+- Main Dockerfile uses Poetry 1.7.1 and Python 3.11
+- Requires SSH mount for private tinkoff-grpc dependency
+
+### Running Tests
+- Test files located in `market_trade/tests/`
+- Run test: `python market_trade/tests/test_decision.py`
+- Run specific test: `python market_trade/tests/test_dataloader.py`
+
+### Data Tools
+Scripts in `tools/` directory for data collection:
+- `save_currencies_data.py` - Collect currency market data
+- `save_shares_data.py` - Collect stock market data
+- `get_shares_stats.py` - Generate trading statistics
+- Usage: `python tools/<script_name>.py [options]`
+
+## Architecture
+
+### Core Trading Pipeline (docs/trading-flow.md)
+
+The system follows this data flow:
+1. **SELECT INSTRUMENT** - Choose trading instrument
+2. **GET_CANDLES(10000)** - Fetch historical candlestick data
+3. **RETRO TRAINING** - Backtest signals on historical data
+4. **STREAM PROCESSING**:
+   - Receive real-time market messages
+   - Accumulate data in sliding window
+   - Update window with each new message
+   - Generate trading signals
+
+### Module Structure
+
+#### `market_trade/core/` - Core Trading Logic
+
+**Signal Processing Chain:**
+1. **Indicators** (`indicators.py`, `indicators_v2.py`) - Technical indicator calculation
+   - Base class: `coreIndicator`
+   - Bollinger Bands: `ind_BB`
+   - All indicator classes (Ind_*.py): ADX, Alligator, DonchianChannel, Envelopes, Gator, Ishimoku, LRI, STD, Stochastic, bollingerBands
+
+2. **Signals** (`signals.py`, `signals_v2.py`) - Signal generation from indicators
+   - Base class: `coreSignalTrande` with three modes:
+     - `online` - Real-time signal generation
+     - `retro` - Expanding window backtesting
+     - `retroFast` - Sliding window backtesting
+   - Signal implementations: `signal_BB` (Bollinger Bands signal)
+   - Aggregator: `signalAgrigator` manages multiple signal instances
+
+3. **Decision Manager** (`decisionManager.py`, `decisionManager_v2.py`) - Trading decisions
+   - Class: `decsionManager`
+   - Combines signals from `signalAgrigator`
+   - Uses `trandeVoter` for probability matrix generation
+   - Methods:
+     - `getSignalTest()` - Test signal generation
+     - `generateMatrixProbability()` - Create probability matrices from backtest
+     - `getOnlineAns()` - Real-time decision making
+
+4. **Trade Voter** (`trandeVoter.py`) - Probability-based decision weighting
+   - Generates probability matrices from historical signal performance
+   - Weights multiple signals to produce final decision
+
+5. **Risk Manager** (`riskManager.py`) - Position sizing and risk controls
+   - Class: `riskManager`
+   - Combines signal decisions with risk parameters
+
+6. **Deal Manager** (`dealManager.py`) - Trade execution and management
+   - Class: `DealManager`
+   - Manages active positions and orders
+
+**Helper Modules:**
+- `CoreTradeMath.py` - Mathematical operations for indicators (moving averages, STD)
+- `CoreDraw.py` - Visualization utilities for indicators and signals
+
+#### `market_trade/data/` - Data Loading
+
+- `dataloader.py` - Contains `DukaMTInterface` class
+  - Converts Dukascopy format candlestick data to internal format
+  - Separates bid/ask candlesticks from multi-indexed CSV
+  - Handles both file paths and DataFrames
+
+#### `market_trade/tests/` - Testing
+
+- Test files demonstrate usage patterns:
+  - `test_decision.py` - Shows complete decision manager workflow with retro training
+  - `test_dataloader.py` - Data loading tests
+
+### External Dependencies
+
+- **tinkoff-grpc** - Private GitHub repo for Tinkoff Invest API integration
+  - Located at: `git@github.com:strategy155/tinkoff_grpc.git`
+  - Used in tools for market data collection
+- **Data Analysis**: pandas, numpy, scipy, matplotlib, plotly, mplfinance
+- **Web Scraping**: requests-html, beautifulsoup4, selenium
+- **Development**: JupyterLab (notebooks in `notebooks/`)
+
+## Key Constants (market_trade/constants.py)
+
+- `ROOT_PATH` - Project root directory
+- `CANDLESTICK_DATASETS_PATH` - Path to candlestick data: `data/candlesticks/`
+- `TEST_CANDLESTICKS_PATH` - Test dataset: `data/EURUSD_price_candlestick.csv`
+- `TINKOFF_TOKEN_STRING` - Production API token (from .env)
+- `SANDBOX_TOKEN_STRING` - Sandbox API token (from .env)
+- `TINKOFF_API_ADDRESS` - API endpoint: 'invest-public-api.tinkoff.ru:443'
+
+## Data Formats
+
+### Candlestick Data
+Expected DataFrame columns:
+- `date` - Timestamp
+- `open`, `high`, `low`, `close` - OHLC price data
+- For bid/ask data: Multi-indexed with ('bid'/'ask', 'open'/'high'/'low'/'close')
+
+### Signal Configuration Dictionary
+```python
+{
+    'signal_name': {
+        'className': signal_class,  # e.g., sig_BB
+        'indParams': {...},          # Indicator parameters
+        'signalParams': {            # Signal parameters
+            'source': 'close',       # Source price column
+            'target': 'close'        # Target price column for analysis
+        },
+        'batchSize': 30              # Window size
+    }
+}
+```
+
+## Development Notes
+
+- Code contains Russian comments and variable names (e.g., "агрегатор", "индикаторы")
+- Version 2 modules (`*_v2.py`) represent newer implementations
+- The system uses sliding window approach for real-time signal generation
+- Backtesting generates probability matrices that weight signal reliability
+- Data symlink: `data/` -> `/var/data0/markettrade_data`

docs/trading-flow.md

@@ -0,0 +1,15 @@
+
+
+STREAM OF INFORMATION
+
+RETRO > TRAINING
+
+1. SELECT INTSTRUMENT
+2. GET_CANDLES(10000)
+3. RETRO
+
+starting the stream
+1. we received messages
+2. we wait for a window to accumulate
+3. then each message receive, we update the window
+4. and get the answer of the signal

market_trade/core/CoreDraw.py

@@ -25,7 +25,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 init_notebook_mode()
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import plotly.express as px
 
 

market_trade/core/CoreTradeMath.py

@@ -19,15 +19,14 @@ import datetime
 
 class CoreMath:
     
-    def __init__(self, base_df, params={
+    def __init__(self, base_df, params=None):
+        default_params = {
             'dataType':'ohcl',
             'action': None,
             'actionOptions':{}
         }
-                ):
-    
         self.base_df=base_df.reset_index(drop=True)
-        self.params=params
+        self.params=params if params is not None else default_params
         if self.params['dataType']=='ohcl':
             self.col=self.base_df[self.params['actionOptions']['valueType']]
         elif self.params['dataType']=='series':

market_trade/core/Ind_ADX.py

@@ -25,7 +25,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import market_trade.core.CoreDraw
 init_notebook_mode()
 
@@ -82,7 +82,7 @@ class ADXI:
             'action':'findMean',
             'actionOptions':{'MeanType':'EMA','span':10}
         }        
-        ans=np.asarray(CoreTraidMath.CoreMath(ser,op).ans)
+        ans=np.asarray(CoreTradeMath.CoreMath(ser,op).ans)
         #print(ans)
         #ans = np.asarray(ser.ewm(span=40,adjust=False).mean().to_list())
         #print(ans)

market_trade/core/Ind_Alligator.py

@@ -24,7 +24,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 init_notebook_mode()
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import market_trade.core.CoreDraw
 
 
@@ -46,7 +46,7 @@ class Alligator:
                                  'valueType':self.options['valueType'],
                                  'window':self.options[keyAns]['window']}
             }
-        ans=market_trade.core.CoreTraidMath.CoreMath(self.base_df,op).ans
+        ans=market_trade.core.CoreTradeMath.CoreMath(self.base_df,op).ans
         
         return ans
     

market_trade/core/Ind_DonchianChannel.py

@@ -24,7 +24,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 init_notebook_mode()
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import market_trade.core.CoreDraw
 
 
@@ -62,9 +62,9 @@ class IDC:
         }
         
         for i in range(self.options['window'],len(self.base_df)-self.options['shift']+1):
-            ans['MaxExt'].append(CoreTraidMath.CoreMath(self.base_df[i-self.options['window']:i],opMax).ans)
+            ans['MaxExt'].append(CoreTradeMath.CoreMath(self.base_df[i-self.options['window']:i],opMax).ans)
             ans['x'].append(self.base_df['date'][i-1+self.options['shift']])
-            ans['MinExt'].append(CoreTraidMath.CoreMath(self.base_df[i-self.options['window']:i],opMin).ans)
+            ans['MinExt'].append(CoreTradeMath.CoreMath(self.base_df[i-self.options['window']:i],opMin).ans)
         return ans
     
     

market_trade/core/Ind_Envelopes.py

@@ -24,7 +24,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 init_notebook_mode()
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import market_trade.core.CoreDraw
 
 class Envelopes:
@@ -64,7 +64,7 @@ class Envelopes:
         }
         if dictResp['MeanType']=='SMA':
 
-            y=market_trade.core.CoreTraidMath.CoreMath(self.base_df,op).ans
+            y=market_trade.core.CoreTradeMath.CoreMath(self.base_df,op).ans
             ans['MainEnv']=y[:len(y)-self.options['shift']]
             ans['PlusEnv']=ans['MainEnv']*(1+self.options['kProc']/100)
             ans['MinusEnv']=ans['MainEnv']*(1-self.options['kProc']/100)

market_trade/core/Ind_Gator.py

@@ -24,7 +24,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 init_notebook_mode()
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import market_trade.core.CoreDraw
 import market_trade.core.Ind_Alligator
 

market_trade/core/Ind_Ishimoku.py

@@ -25,7 +25,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 import market_trade.core.CoreDraw
 init_notebook_mode()
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import plotly.express as px
 
 

market_trade/core/Ind_LRI.py

@@ -25,7 +25,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 init_notebook_mode()
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import market_trade.core.CoreDraw
 
 

market_trade/core/Ind_STD.py

@@ -25,7 +25,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 init_notebook_mode()
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import market_trade.core.CoreDraw
 
 class ISTD:
@@ -53,7 +53,7 @@ class ISTD:
                     'actionOptions':{'valueType':self.options['valueType']}
                 }
             x=self.base_df['date'].to_list()
-        y= CoreTraidMath.CoreMath(self.base_df,op).ans
+        y= CoreTradeMath.CoreMath(self.base_df,op).ans
         ans={'y':y,'x':x}
 
         

market_trade/core/Ind_Stochastic.py

@@ -25,7 +25,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 init_notebook_mode()
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import market_trade.core.CoreDraw
 
 class Stochastic:
@@ -69,7 +69,7 @@ class Stochastic:
             'action':'findMean',
             'actionOptions':{'MeanType':'SMA','window':self.options['windowSMA']}
         }        
-        ans=np.asarray(market_trade.core.CoreTraidMath.CoreMath(ser,op).ans)
+        ans=np.asarray(market_trade.core.CoreTradeMath.CoreMath(ser,op).ans)
         return ans
         #return np.convolve(col, np.ones(self.options['windowSMA']), 'valid') /self.options['windowSMA']
         

market_trade/core/Ind_bollingerBands.py

@@ -24,7 +24,7 @@ from plotly.offline import init_notebook_mode, iplot
 from plotly.subplots import make_subplots
 init_notebook_mode()
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import market_trade.core.CoreDraw
 
 
@@ -50,12 +50,12 @@ class BB:
                 'window':self.options['window']
             }
         }
-        ans['BB']=market_trade.core.CoreTraidMath.CoreMath(self.base_df,opMA).ans
+        ans['BB']=market_trade.core.CoreTradeMath.CoreMath(self.base_df,opMA).ans
         opSTD={'dataType':'ohcl',
             'action':'findSTD',
             'actionOptions':{'valueType':self.options['valueType'],'window':self.options['window']}
         }
-        ans['STD']=market_trade.core.CoreTraidMath.CoreMath(self.base_df,opSTD).ans
+        ans['STD']=market_trade.core.CoreTradeMath.CoreMath(self.base_df,opSTD).ans
         ans['pSTD']=ans['BB']+ans['STD']*self.options['kDev']
         ans['mSTD']=ans['BB']-ans['STD']*self.options['kDev']
         ans['x']=np.array(self.base_df['date'][self.options['window']-1:].to_list())

market_trade/core/dealManager.py

@@ -3,15 +3,30 @@ import datetime
 import numpy as np
 import uuid
 
+
 class DealManager():
+    """Manages open trading positions and deal lifecycle.
+
+    Tracks active positions with their entry prices and quantities,
+    supporting both opening new positions and closing existing ones.
+    """
 
     def __init__(self):
-        #self.commission=0.04
+        """Initialize DealManager with empty deals DataFrame."""
         self.columns = ['uuid', 'figi', 'amount', 'startPrice']
         self.deals = pd.DataFrame(columns=self.columns)
         self.deals = self.deals.set_index('uuid')
 
-    def findDealByPriceAndFig(self,price,figi):
+    def find_deal_by_price_and_figi(self, price: float, figi: str):
+        """Find existing deal by price and instrument identifier.
+
+        Args:
+            price: Entry price to search for.
+            figi: Financial Instrument Global Identifier.
+
+        Returns:
+            Deal UUID if found, None otherwise.
+        """
         ans = None
         for i in range(self.deals.shape[0]):
             if self.deals.iloc[i].startPrice == price and self.deals.iloc[i].figi == figi:
@@ -19,31 +34,44 @@ class DealManager():
                 break
         return ans
 
-    def openDeal(self,figi,startPrice,amount=1):
+    def open_deal(self, figi: str, start_price: float, amount: int = 1) -> None:
-        desiredDeal=self.findDealByPriceAndFig(startPrice,figi)
+        """Open new deal or add to existing position.
-        if desiredDeal == None:
+
-            newDealDict={
+        If a deal with the same FIGI and price exists, adds to the amount.
+        Otherwise creates a new deal entry.
+
+        Args:
+            figi: Financial Instrument Global Identifier.
+            start_price: Entry price for the position.
+            amount: Number of units to trade (default 1).
+        """
+        desired_deal = self.find_deal_by_price_and_figi(start_price, figi)
+        if desired_deal is None:
+            new_deal_dict = {
                 'uuid': [str(uuid.uuid4())],
                 'figi': [figi],
-                'startPrice':[startPrice],
+                'startPrice': [start_price],
                 'amount': [amount]
             }
 
-            #newDealDict['profit']=[startPrice*pow(1+self.commission,2)]
+            new_deal = pd.DataFrame.from_dict(new_deal_dict).set_index('uuid')
-
+            self.deals = pd.concat([self.deals, new_deal])
-
-
-            newDeal=pd.DataFrame.from_dict(newDealDict).set_index('uuid')
-            self.deals=pd.concat([self.deals, newDeal])
         else:
-            self.deals.at[desiredDeal,'amount'] += amount
+            self.deals.at[desired_deal, 'amount'] += amount
 
-    def closeDeal(self,uuid,amount):
+    def close_deal(self, uuid_str: str, amount: int) -> None:
+        """Close deal partially or completely.
 
-        desiredDeal=self.deals.loc[uuid]
+        Args:
-        if desiredDeal.amount - amount == 0:
+            uuid_str: Deal UUID to close.
-            self.deals = self.deals.drop(labels = [uuid],axis = 0)
+            amount: Number of units to close.
+
+        Note:
+            If amount equals deal amount, removes deal entirely.
+            Otherwise decreases deal amount.
+        """
+        desired_deal = self.deals.loc[uuid_str]
+        if desired_deal.amount - amount == 0:
+            self.deals = self.deals.drop(labels=[uuid_str], axis=0)
         else:
-            self.deals.at[uuid,'amount'] -= amount
+            self.deals.at[uuid_str, 'amount'] -= amount
-            #self.deals.loc[uuid].amount = desiredDeal.amount - amount
-        

market_trade/core/decisionManager_v2.py

@@ -1,4 +1,5 @@
 import os
+import pickle
 
 import pandas as pd
 import datetime
@@ -6,17 +7,24 @@ import numpy as np
 
 from tqdm import tqdm
 
-from market_trade.core.indicators_v2 import *
+from market_trade.core.indicators_v2 import ind_BB
-from market_trade.core.signals_v2 import *
+from market_trade.core.signals_v2 import sig_BB, SignalsAggregator
-from market_trade.core.dealManager import *
+from market_trade.core.dealManager import DealManager
-from market_trade.core.trandeVoter import *
+from market_trade.core.trandeVoter import TradeVoter
-from market_trade.core.riskManager import *
+from market_trade.core.riskManager import RiskManager
-import pickle
 
 
-class decsionManager:
+class DecisionManager:
-    '''
+    """Manages trading decisions based on signals, probability voting, and risk management.
-sigAgrReq = {
+
+    Coordinates the entire decision-making pipeline:
+    1. Signals from indicators
+    2. Probability-based voting (TradeVoter)
+    3. Risk assessment (RiskManager)
+    4. Deal tracking (DealManager)
+
+    Example configuration:
+        sig_config = {
             'sig_BB': {
                 'className': sig_BB,
                 'params': {'source': 'close', 'target': 'close'},
@@ -26,72 +34,62 @@ sigAgrReq = {
                         'params': {'MeanType': 'SMA', 'window': 30, 'valueType': 'close', 'kDev': 2.5}
                     }
                 }
-    },
-    'sig_BB_2':{
-        'className':sig_BB,
-        'params':{'source':'close','target':'close'},
-        'indicators':{
-            'ind_BB':{
-                'className':ind_BB,
-                'params':{'MeanType':'SMA','window':30,'valueType':'close','kDev':2}
-            }            
-        }
             }
         }
+    """
 
-sigAgrData = {
+    def __init__(self, name: str, sig_dict: dict):
-    'sig_BB':{
+        """Initialize DecisionManager with configuration.
-        'signalData': df_candle[990:1000],
-        'indicatorData' :{'ind_BB': df_candle[:1000]}
-    },
-    'sig_BB_2':{
-        'signalData': df_candle[990:1000],
-        'indicatorData' :{'ind_BB': df_candle[:1000]}
-    }    
-}
 
-
+        Args:
-sigAgrRetroTemplate = {
+            name: Identifier for this decision manager instance.
-    'sig_BB':{
+            sig_dict: Dictionary of signal configurations.
-        'signalData': None,
+        """
-        'indicatorData' :{'ind_BB': None}
+        self.RM = RiskManager()
-    },
-    'sig_BB_2':{
-        'signalData': None,
-        'indicatorData' :{'ind_BB': None}
-    }     
-}    
-    
-    
-    
-    
-    
-    
-    '''
-    
-    
-    
-    
-    def __init__(self,name, sigDict: dict):
-        self.RM = riskManager()
         self.DM = DealManager()
-        self.TV = trandeVoter(name)
+        self.TV = TradeVoter(name)
-        self.SA = signalsAgrigator(sigDict)
+        self.SA = SignalsAggregator(sig_dict)
-        self.sigDict = sigDict
+        self.sig_dict = sig_dict
 
+    def get_online_answer(self, signals_ans: dict, price: float) -> dict:
+        """Get trading decision for current market conditions.
 
-    def getOnlineAns(self, signalsAns: dict, price: float) -> dict:
+        Args:
-        probabilityDecsion = self.TV.getDecisionBySignals(self.getSignalsAns(signalsAns))
+            signals_ans: Dictionary of signal data.
-        RMD = self.RM.getDecision(probabilityDecision=probabilityDecsion, price=price, deals = self.DM.deals)
+            price: Current market price.
-        return RMD
 
-    def getSignalsAns(self, signalsDataDict: dict) -> dict:
+        Returns:
-        return self.SA.getAns(signalsDataDict)
+            Risk-adjusted decision dictionary.
+        """
+        probability_decision = self.TV.get_decision_by_signals(self.get_signals_answer(signals_ans))
+        rmd = self.RM.get_decision(
+            probability_decision=probability_decision,
+            price=price,
+            deals=self.DM.deals
+        )
+        return rmd
 
-    def getRightAns(self,value_1, value_2):
+    def get_signals_answer(self, signals_data_dict: dict) -> dict:
+        """Get answers from all configured signals.
 
-        ans=''
+        Args:
+            signals_data_dict: Dictionary of signal data inputs.
 
+        Returns:
+            Dictionary of signal results.
+        """
+        return self.SA.get_answer(signals_data_dict)
+
+    def get_right_answer(self, value_1: float, value_2: float) -> str:
+        """Determine correct direction based on value comparison.
+
+        Args:
+            value_1: First value (current).
+            value_2: Second value (next).
+
+        Returns:
+            Direction: 'down' if value decreases, 'up' if increases, 'none' if same.
+        """
         if value_1 > value_2:
             ans = 'down'
         elif value_1 < value_2:
@@ -101,61 +99,89 @@ sigAgrRetroTemplate = {
 
         return ans
 
-    def getRetroTrendAns(self, retroTemplateDict: dict, data: pd.DataFrame(), window: int) -> list:
+    def get_retro_trend_answer(self, retro_template_dict: dict, data: pd.DataFrame, window: int) -> dict:
+        """Run retrospective analysis on historical data.
 
-        reqSig={} 
+        Slides a window through historical data to generate training data
+        for probability matrix generation.
+
+        Args:
+            retro_template_dict: Template defining signal structure.
+            data: Historical market data.
+            window: Size of sliding window.
+
+        Returns:
+            Dictionary with 'signalsAns' and 'rightAns' lists.
+        """
+        req_sig = {}
         ans = {
             'signalsAns': [],
             'rightAns': []
-            
         }
         target = ''
 
-        
         for k in tqdm(range(data.shape[0] - window - 1)):
-            for i in retroTemplateDict.keys():
+            for i in retro_template_dict.keys():
-                reqSig[i] = {'signalData': data[k:k+window], 'indicatorData':{}}
+                req_sig[i] = {'signalData': data[k:k+window], 'indicatorData': {}}
                 target = self.SA.signals[i].params['target']
-                for j in retroTemplateDict[i]['indicatorData'].keys():
+                for j in retro_template_dict[i]['indicatorData'].keys():
-                    reqSig[i]['indicatorData'][j] = data[k:k+window]
+                    req_sig[i]['indicatorData'][j] = data[k:k+window]
 
-            sigAns = self.getSignalsAns(reqSig)
+            sig_ans = self.get_signals_answer(req_sig)
-            rightAns = self.getRightAns(data[target][k], data[target][k+1])
+            right_ans = self.get_right_answer(data[target][k], data[target][k+1])
 
-            ans['signalsAns'].append(sigAns)
+            ans['signalsAns'].append(sig_ans)
-            ans['rightAns'].append(rightAns)
+            ans['rightAns'].append(right_ans)
 
         return ans
 
+    def generate_matrix_probability_from_dict(self, dict_signals: dict) -> None:
+        """Generate probability matrices from retrospective signal data.
 
-    def generateMatrixProbabilityFromDict(self, dictSignals: dict) -> dict:
+        Args:
-        self.TV.createMatrixAmounts(dictSignals['signalsAns'][0].keys())
+            dict_signals: Dictionary containing 'signalsAns' and 'rightAns' from retro analysis.
-        for i in range(len(dictSignals['signalsAns'])):
+        """
-            self.TV.setDecisionBySignals(signalDecisions = dictSignals['signalsAns'][i],
+        self.TV.create_matrix_amounts(dict_signals['signalsAns'][0].keys())
-                                        trande = dictSignals['rightAns'][i])
+        for i in range(len(dict_signals['signalsAns'])):
-        self.TV.generateMatrixProbability()
+            self.TV.set_decision_by_signals(
+                signal_decisions=dict_signals['signalsAns'][i],
+                trande=dict_signals['rightAns'][i]
+            )
+        self.TV.generate_matrix_probability()
 
-    def createDump(self,postfix='') -> str:
+    def create_dump(self, postfix: str = '') -> str:
-        dataDict = {
+        """Save decision manager state to pickle file.
+
+        Args:
+            postfix: Optional postfix for filename.
+
+        Returns:
+            Absolute path to saved file.
+        """
+        data_dict = {
             'RM': self.RM,
             'DM': self.DM,
             'TV': self.TV,
             'SA': self.SA,
-            'sigDict':self.sigDict
+            'sigDict': self.sig_dict
         }
-        fileName='data_'+postfix+'.pickle'
+        file_name = 'data_' + postfix + '.pickle'
-        with open(fileName, 'wb') as f:
+        with open(file_name, 'wb') as f:
-            pickle.dump(dataDict, f)
+            pickle.dump(data_dict, f)
 
-        return os.path.abspath(fileName)
+        return os.path.abspath(file_name)
 
-    def loadDump(self,path: str) -> None:
+    def load_dump(self, path: str) -> None:
+        """Load decision manager state from pickle file.
 
+        Args:
+            path: Path to pickle file.
+        """
         with open(path, 'rb') as f:
-            dataDict = pickle.load(f)
+            data_dict = pickle.load(f)
 
-        self.RM = dataDict['RM']
+        self.RM = data_dict['RM']
-        self.DM = dataDict['DM']
+        self.DM = data_dict['DM']
-        self.TV = dataDict['TV']
+        self.TV = data_dict['TV']
-        self.SA = dataDict['SA']
+        self.SA = data_dict['SA']
-        self.sigDict = dataDict['sigDict']
+        self.sig_dict = data_dict['sigDict']

market_trade/core/indicators.py

@@ -2,7 +2,7 @@ import pandas as pd
 import datetime
 import numpy as np
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import market_trade.core.CoreDraw
 
 class coreIndicator():
@@ -99,12 +99,12 @@ class ind_BB(coreIndicator):
                 'window':self.options['window']
             }
         }
-        ans['BB']=market_trade.core.CoreTraidMath.CoreMath(self.data,opMA).ans
+        ans['BB']=market_trade.core.CoreTradeMath.CoreMath(self.data,opMA).ans
         opSTD={'dataType':'ohcl',
             'action':'findSTD',
             'actionOptions':{'valueType':self.options['valueType'],'window':self.options['window']}
         }
-        ans['STD']=market_trade.core.CoreTraidMath.CoreMath(self.data,opSTD).ans
+        ans['STD']=market_trade.core.CoreTradeMath.CoreMath(self.data,opSTD).ans
         ans['pSTD']=ans['BB']+ans['STD']*self.options['kDev']
         ans['mSTD']=ans['BB']-ans['STD']*self.options['kDev']
         ans['x']=np.array(self.data['date'][self.options['window']-1:].to_list())

market_trade/core/indicators_v2.py

@@ -2,72 +2,138 @@ import pandas as pd
 import datetime
 import numpy as np
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 
-class coreIndicator():
 
-    def __init__(self,options: dict, dataType: str = None, predictType: str = None, name: str = None):
+class CoreIndicator():
+    """Base class for technical indicators.
+
+    This class provides the foundation for implementing various technical
+    indicators used in trading signal generation.
+    """
+
+    def __init__(self, options: dict, data_type: str = None, predict_type: str = None, name: str = None):
+        """Initialize CoreIndicator with configuration options.
+
+        Args:
+            options: Dictionary containing indicator-specific parameters.
+            data_type: Type of data to process (e.g., 'ohlc'). Defaults to None.
+            predict_type: Type of prediction to make (e.g., 'trend'). Defaults to None.
+            name: Optional identifier. Defaults to None.
+        """
         self.options = options
-        self.dataType = dataType #ochl
+        self.data_type = data_type  # ohlc
-        self.predictType = predictType #trend
+        self.predict_type = predict_type  # trend
 
+    def get_answer(self, data: pd.DataFrame):
+        """Get indicator answer from data.
 
-    def getAns(self, data: pd.DataFrame() ):
+        Args:
+            data: DataFrame containing market data.
+
+        Returns:
+            Calculated indicator values or "ERROR" if not implemented.
+        """
         return "ERROR"
 
-class indicatorsAgrigator:
+
-    """
+class IndicatorsAggregator:
+    """Aggregates and manages multiple indicator instances.
+
+    Example usage:
         indicators = {
             'ind_BB': {
                 'className': ind_BB,
                 'params': {'MeanType': 'SMA', 'window': 15, 'valueType': 'close', 'kDev': 2.5}
             }
         }
-    dataDic={
+        data_dict = {
             'ind_BB': df_candle[:1000]
         }
-    
+        aggregator = IndicatorsAggregator(indicators)
-    
+        results = aggregator.get_answer(data_dict)
     """
 
-    def __init__ (self,indDict={}):
+    def __init__(self, ind_dict=None):
-        self.indDict = indDict
+        """Initialize aggregator with indicator dictionary.
-        self.indInst = {}
+
+        Args:
+            ind_dict: Dictionary mapping indicator names to configurations.
+                Defaults to empty dict if not provided.
+        """
+        self.ind_dict = ind_dict if ind_dict is not None else {}
+        self.ind_instances = {}
         self.ans = {}
-        self.createIndicatorsInstance()
+        self.create_indicators_instance()
 
-    def createIndicatorsInstance(self):
+    def create_indicators_instance(self):
-        for i in self.indDict.keys():
+        """Create instances of all configured indicators."""
-            self.indInst[i]=self.indDict[i]['className'](self.indDict[i]['params'])
+        for i in self.ind_dict.keys():
+            self.ind_instances[i] = self.ind_dict[i]['className'](self.ind_dict[i]['params'])
 
-    def getAns(self,dataDict={}):
+    def get_answer(self, data_dict=None):
+        """Calculate answers from all indicators.
+
+        Args:
+            data_dict: Dictionary mapping indicator names to their data.
+                Defaults to empty dict.
+
+        Returns:
+            Dictionary of indicator results.
+        """
+        if data_dict is None:
+            data_dict = {}
         ans = {}
-        for i in dataDict.keys():
+        for i in data_dict.keys():
-            ans[i] = self.indInst[i].getAns(dataDict[i])
+            ans[i] = self.ind_instances[i].get_answer(data_dict[i])
         return ans
 
-class ind_BB(coreIndicator):
-    """
-    options
-        MeanType -> SMA
-        window -> int
-        valueType -> str: low, high, open, close
-        kDev -> float
 
+class ind_BB(CoreIndicator):
+    """Bollinger Bands indicator implementation.
+
+    Calculates Bollinger Bands using moving average and standard deviation.
+
+    Required options:
+        MeanType: Type of moving average (e.g., 'SMA')
+        window: Period for calculations (int)
+        valueType: Price type to use ('low', 'high', 'open', 'close')
+        kDev: Standard deviation multiplier (float)
     """
 
     def __init__(self, options: dict, name=None):
+        """Initialize Bollinger Bands indicator.
+
+        Args:
+            options: Configuration parameters dictionary.
+            name: Optional identifier.
+        """
         super().__init__(
             options=options,
-            dataType = 'ochl',
+            data_type='ohlc',
-            predictType = 'trend',
+            predict_type='trend',
             name=name
         )
 
-    def getAns(self, data: pd.DataFrame()):
+    def get_answer(self, data: pd.DataFrame):
+        """Calculate Bollinger Bands values.
+
+        Args:
+            data: DataFrame with OHLC price data.
+
+        Returns:
+            Dictionary containing:
+                - BB: Middle band (moving average)
+                - STD: Standard deviation
+                - pSTD: Upper band (BB + kDev * STD)
+                - mSTD: Lower band (BB - kDev * STD)
+                - x: Date array
+        """
         data = data.reset_index(drop=True)
         ans = {}
-        opMA={'dataType':'ohcl',
+
+        op_ma = {
+            'dataType': 'ohcl',
             'action': 'findMean',
             'actionOptions': {
                 'MeanType': self.options['MeanType'],
@@ -75,15 +141,19 @@ class ind_BB(coreIndicator):
                 'window': self.options['window']
             }
         }
-        ans['BB']=market_trade.core.CoreTraidMath.CoreMath(data,opMA).ans
+        ans['BB'] = market_trade.core.CoreTradeMath.CoreMath(data, op_ma).ans
-        opSTD={'dataType':'ohcl',
+
+        op_std = {
+            'dataType': 'ohcl',
             'action': 'findSTD',
-            'actionOptions':{'valueType':self.options['valueType'],'window':self.options['window']}
+            'actionOptions': {
+                'valueType': self.options['valueType'],
+                'window': self.options['window']
             }
-        ans['STD']=market_trade.core.CoreTraidMath.CoreMath(data,opSTD).ans
+        }
+        ans['STD'] = market_trade.core.CoreTradeMath.CoreMath(data, op_std).ans
         ans['pSTD'] = ans['BB'] + ans['STD'] * self.options['kDev']
         ans['mSTD'] = ans['BB'] - ans['STD'] * self.options['kDev']
         ans['x'] = np.array(data['date'][self.options['window']-1:].to_list())
         self.ans = ans
         return ans
-    

market_trade/core/riskManager.py

@@ -3,27 +3,54 @@ import datetime
 import numpy as np
 import random
 
-class riskManager:
 
-    def __init__(self,commision=0.04):
+class RiskManager:
-        self.commision = commision
+    """Manages risk assessment and position sizing for trading decisions.
-        pass
+
-    def getDecision(self,probabilityDecision, price, deals=None) -> dict:
+    Evaluates trading decisions from probability-based signals and applies
+    risk management rules including commission calculations and profit targets.
+    """
+
+    def __init__(self, commission: float = 0.04):
+        """Initialize RiskManager with commission rate.
+
+        Args:
+            commission: Commission rate as decimal (default 0.04 = 4%).
+        """
+        self.commission = commission
+
+    def get_decision(self, probability_decision: dict, price: float, deals: pd.DataFrame = None) -> dict:
+        """Evaluate trading decision with risk management rules.
+
+        Args:
+            probability_decision: Dictionary containing 'trande' direction from TradeVoter.
+            price: Current market price.
+            deals: DataFrame of active positions (optional).
+
+        Returns:
+            Dictionary with 'decision' ('buy', 'sell', 'none') and additional fields:
+                - For 'buy': includes 'amount' field
+                - For 'sell': includes 'deals' list of position UUIDs to close
+        """
         ans = {}
         ans['decision'] = 'none'
-        if probabilityDecision['trande'] == 'up':
+
+        if probability_decision['trande'] == 'up':
             ans['decision'] = 'buy'
             ans['amount'] = 1
-        elif probabilityDecision['trande'] == 'none':
+
+        elif probability_decision['trande'] == 'none':
             ans['decision'] = 'none'
-        elif probabilityDecision['trande'] == 'down': 
+
+        elif probability_decision['trande'] == 'down':
+            if deals is not None:
                 for i in range(deals.shape[0]):
-                ans['decision'] = 'None'
+                    ans['decision'] = 'none'
                     ans['deals'] = []
                     row = deals.iloc[i]
+                    # Check if position is profitable after commission
                     if row.startPrice < price * pow(1 + self.commission, 2):
                         ans['decision'] = 'sell'
                         ans['deals'].append(row.name)
+
         return ans
-        
-    

market_trade/core/signals.py

@@ -2,7 +2,7 @@ import pandas as pd
 import datetime
 import numpy as np
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
 import market_trade.core.CoreDraw
 from tqdm import tqdm
 

market_trade/core/signals_v2.py

@@ -2,49 +2,101 @@ import pandas as pd
 import datetime
 import numpy as np
 
-import market_trade.core.CoreTraidMath
+import market_trade.core.CoreTradeMath
-#import market_trade.core.CoreDraw
 from tqdm import tqdm
 
-from market_trade.core.indicators_v2 import *
+from market_trade.core.indicators_v2 import IndicatorsAggregator, ind_BB
 
 
+class CoreSignalTrade:
+    """Base class for trading signals.
 
-class coreSignalTrande:
+    Provides foundation for generating trading signals based on technical indicators.
-    
-    def __init__(self, name: str, req: dict, dataType: str):
-        self.name = name
-        self.agrigateInds = self.createIndicatorsInstance(req)
-        self.params = req['params']
-        self.dataType = dataType
-        
-    
-    def createIndicatorsInstance(self,req: dict) -> dict:
-        return indicatorsAgrigator(req['indicators'])
-    
-    def getIndAns(self, dataDict: dict) -> dict:
-        return self.agrigateInds.getAns(dataDict)
-    
-    def getAns(self, data: pd.DataFrame(), indDataDict: dict) -> dict:
-        return self.getSigAns(data, self.getIndAns(indDataDict)) 
-        
-    
-    
-class sig_BB(coreSignalTrande):
     """
-    ind keys:
+
-        ind_BB
+    def __init__(self, name: str, req: dict, data_type: str):
+        """Initialize signal generator.
+
+        Args:
+            name: Signal identifier.
+            req: Configuration dictionary containing params and indicators.
+            data_type: Type of data to process (e.g., 'ohlc').
+        """
+        self.name = name
+        self.aggregate_indicators = self.create_indicators_instance(req)
+        self.params = req['params']
+        self.data_type = data_type
+
+    def create_indicators_instance(self, req: dict) -> IndicatorsAggregator:
+        """Create indicators aggregator from configuration.
+
+        Args:
+            req: Request dictionary containing indicators configuration.
+
+        Returns:
+            IndicatorsAggregator instance.
+        """
+        return IndicatorsAggregator(req['indicators'])
+
+    def get_indicator_answer(self, data_dict: dict) -> dict:
+        """Get answers from all indicators.
+
+        Args:
+            data_dict: Dictionary mapping indicator names to data.
+
+        Returns:
+            Dictionary of indicator results.
+        """
+        return self.aggregate_indicators.get_answer(data_dict)
+
+    def get_answer(self, data: pd.DataFrame, ind_data_dict: dict) -> dict:
+        """Get signal answer from data and indicator results.
+
+        Args:
+            data: Market data DataFrame.
+            ind_data_dict: Dictionary of indicator data.
+
+        Returns:
+            Signal answer (direction).
+        """
+        return self.get_signal_answer(data, self.get_indicator_answer(ind_data_dict))
+
+
+class sig_BB(CoreSignalTrade):
+    """Bollinger Bands signal generator.
+
+    Generates trading signals based on Bollinger Bands indicator:
+    - 'up' when price is below lower band
+    - 'down' when price is above upper band
+    - 'none' when price is within bands
+
+    Required indicator keys:
+        ind_BB: Bollinger Bands indicator
     """
 
     def __init__(self, name: str, req: dict):
-        super().__init__(name, req, 'ochl')
+        """Initialize Bollinger Bands signal.
 
-    def getSigAns(self, data: pd.DataFrame(), indAnsDict: dict) -> dict:
+        Args:
+            name: Signal identifier.
+            req: Configuration dictionary.
+        """
+        super().__init__(name, req, 'ohlc')
 
-        lastValue = data[self.params['source']].to_list()[-1]
+    def get_signal_answer(self, data: pd.DataFrame, ind_ans_dict: dict) -> str:
-        if lastValue>indAnsDict['ind_BB']['pSTD'][-1]:
+        """Calculate signal from Bollinger Bands.
+
+        Args:
+            data: Market data DataFrame.
+            ind_ans_dict: Dictionary containing indicator results.
+
+        Returns:
+            Signal direction: 'up', 'down', or 'none'.
+        """
+        last_value = data[self.params['source']].to_list()[-1]
+        if last_value > ind_ans_dict['ind_BB']['pSTD'][-1]:
             ans = 'down'
-        elif lastValue<indAnsDict['ind_BB']['mSTD'][-1]:
+        elif last_value < ind_ans_dict['ind_BB']['mSTD'][-1]:
             ans = 'up'
         else:
             ans = 'none'
@@ -52,10 +104,11 @@ class sig_BB(coreSignalTrande):
         return ans
 
 
-class signalsAgrigator:
+class SignalsAggregator:
+    """Aggregates and manages multiple signal generators.
 
-    """
+    Example usage:
-    sigAgrReq = {
+        sig_config = {
             'sig_BB': {
                 'className': sig_BB,
                 'params': {'source': 'close', 'target': 'close'},
@@ -65,48 +118,56 @@ class signalsAgrigator:
                         'params': {'MeanType': 'SMA', 'window': 15, 'valueType': 'close', 'kDev': 2.5}
                     }
                 }
-        },
-        'sig_BB_2':{
-            'className':sig_BB,
-            'params':{'source':'close','target':'close'},
-            'indicators':{
-                'ind_BB':{
-                    'className':ind_BB,
-                    'params':{'MeanType':'SMA','window':30,'valueType':'close','kDev':2}
-                }            
-            }
             }
         }
 
-    sigAgrData = {
+        sig_data = {
             'sig_BB': {
                 'signalData': df_candle[990:1000],
                 'indicatorData': {'ind_BB': df_candle[:1000]}
-        },
-        'sig_BB_2':{
-            'signalData': df_candle[990:1000],
-            'indicatorData' :{'ind_BB': df_candle[:1000]}
             }
         }
 
-
+        aggregator = SignalsAggregator(sig_config)
-
+        results = aggregator.get_answer(sig_data)
-
-
     """
 
     def __init__(self, req: dict):
-        self.signals = self.createSignalsInstance(req)
+        """Initialize signals aggregator.
 
-    def createSignalsInstance(self, siganlsDict: dict) -> dict:
+        Args:
+            req: Dictionary mapping signal names to configurations.
+        """
+        self.signals = self.create_signals_instance(req)
+
+    def create_signals_instance(self, signals_dict: dict) -> dict:
+        """Create instances of all configured signals.
+
+        Args:
+            signals_dict: Dictionary of signal configurations.
+
+        Returns:
+            Dictionary of signal instances.
+        """
         ans = {}
-        for i in siganlsDict.keys():
+        for i in signals_dict.keys():
-            ans[i]=siganlsDict[i]['className'](name = i, req = siganlsDict[i])
+            ans[i] = signals_dict[i]['className'](name=i, req=signals_dict[i])
         return ans
 
-    def getAns(self, dataDict: dict) -> dict:
+    def get_answer(self, data_dict: dict) -> dict:
+        """Calculate answers from all signals.
+
+        Args:
+            data_dict: Dictionary mapping signal names to their data.
+                Each entry should contain 'signalData' and 'indicatorData'.
+
+        Returns:
+            Dictionary of signal results.
+        """
         ans = {}
-        for i in dataDict.keys():
+        for i in data_dict.keys():
-            ans[i] = self.signals[i].getAns(data = dataDict[i]['signalData'], 
+            ans[i] = self.signals[i].get_answer(
-                                   indDataDict = dataDict[i]['indicatorData'])
+                data=data_dict[i]['signalData'],
+                ind_data_dict=data_dict[i]['indicatorData']
+            )
         return ans

market_trade/core/trandeVoter.py

@@ -3,82 +3,72 @@ import datetime
 import numpy as np
 #import random
 
-class trandeVoter():
+class TradeVoter():
 
     def __init__(self, name):
 
-        self.name = name # просто имя
+        self.name = name  # Instance identifier
-        self.trandeValuesList = ['up','none','down'] #словарь трегдов
+        self.trade_values_list = ['up', 'none', 'down']  # Valid trade directions
-        self.matrixAmounts = None # матрица сумм
+        self.matrix_amounts = None  # Sum matrix for signal combinations
-        self.keysMatrixAmounts = None #ключи матрицы сумм, техническое поле
+        self.keys_matrix_amounts = None  # Matrix keys, technical field
-        self.matrixProbability = None # матрица вероятностей
+        self.matrix_probability = None  # Probability matrix for decision making
 
 
-    #функция которая создает df с заданным набором колонок и индексов. индексы - уникальные соотношения 
+    # Function to create DataFrame with specified columns and indices. Indices are unique combinations.
-    def createDFbyNames(self, namesIndex, namesColoms,defaultValue=0.0):
+    def create_df_by_names(self, names_index, column_names, default_value=0.0):
-        df = pd.DataFrame(dict.fromkeys(namesColoms, [defaultValue]*pow(3,len(namesIndex))),
+        df = pd.DataFrame(dict.fromkeys(column_names, [default_value]*pow(3, len(names_index))),
-                          index=pd.MultiIndex.from_product([self.trandeValuesList]*len(namesIndex), names=namesIndex)
+                          index=pd.MultiIndex.from_product([self.trade_values_list]*len(names_index), names=names_index)
-                            #,columns=namesColoms
                         )
-        return(df)
+        return df
 
-    #создание матрицы сумм с дефолтным значением
+    # Create sum matrix with default value
-    def createMatrixAmounts(self,namesIndex: list) -> pd.DataFrame():
+    def create_matrix_amounts(self, names_index: list) -> pd.DataFrame:
-        self.matrixAmounts = self.createDFbyNames(namesIndex,self.trandeValuesList,0)
+        self.matrix_amounts = self.create_df_by_names(names_index, self.trade_values_list, 0)
-        self.keysMatrixAmounts = self.matrixAmounts.to_dict('tight')['index_names']
+        self.keys_matrix_amounts = self.matrix_amounts.to_dict('tight')['index_names']
-        self.createMatrixProbability(namesIndex)
+        self.create_matrix_probability(names_index)
-        return(self.matrixAmounts)
+        return self.matrix_amounts
 
-    #создание матрицы вероятностей с дефолтным значением
+    # Create probability matrix with default value
-    def createMatrixProbability(self,namesIndex: list) -> pd.DataFrame():
+    def create_matrix_probability(self, names_index: list) -> pd.DataFrame:
-        self.matrixProbability = self.createDFbyNames(namesIndex,self.trandeValuesList)
+        self.matrix_probability = self.create_df_by_names(names_index, self.trade_values_list)
-        return(self.matrixProbability)
+        return self.matrix_probability
 
-    #установка значений в матрицы сумм. signalDecisions - значения индикаторов key:value; trande - реальное значение
+    # Set values in sum matrix. signalDecisions - indicator values key:value; trande - actual value
-    def setDecisionBySignals(self,signalDecisions: dict,trande: str) -> None:
+    def set_decision_by_signals(self, signal_decisions: dict, trande: str) -> None:
         buff = []
-        for i in self.keysMatrixAmounts:
+        for i in self.keys_matrix_amounts:
-            buff.append(signalDecisions[i])
+            buff.append(signal_decisions[i])
-        self.matrixAmounts.loc[tuple(buff),trande] += 1
+        self.matrix_amounts.loc[tuple(buff), trande] += 1
 
-    #заполнение матрицы вероятностей вычисляемыми значениями из матрицы сумм
+    # Fill probability matrix with calculated values from sum matrix
-    def generateMatrixProbability(self) -> None:
+    def generate_matrix_probability(self) -> None:
-        for i in range(self.matrixAmounts.shape[0]):
+        for i in range(self.matrix_amounts.shape[0]):
-            print(self.matrixAmounts)
+            print(self.matrix_amounts)
-            rowSum=sum(self.matrixAmounts.iloc[i]) + 1
+            row_sum = sum(self.matrix_amounts.iloc[i]) + 1
-            self.matrixProbability.iloc[i]['up'] = self.matrixAmounts.iloc[i]['up'] / rowSum
+            self.matrix_probability.iloc[i]['up'] = self.matrix_amounts.iloc[i]['up'] / row_sum
-            self.matrixProbability.iloc[i]['none'] = self.matrixAmounts.iloc[i]['none'] / rowSum
+            self.matrix_probability.iloc[i]['none'] = self.matrix_amounts.iloc[i]['none'] / row_sum
-            self.matrixProbability.iloc[i]['down'] = self.matrixAmounts.iloc[i]['down'] / rowSum
+            self.matrix_probability.iloc[i]['down'] = self.matrix_amounts.iloc[i]['down'] / row_sum
 
-    #получение рещения из матрицы вероятностей по заданным значениям сигналов
+    # Get decision from probability matrix based on signal values
-    def getDecisionBySignals(self,signalDecisions: dict) -> dict:
+    def get_decision_by_signals(self, signal_decisions: dict) -> dict:
         ans = {}
-        spliceSearch =self.matrixProbability.xs(tuple(signalDecisions.values()),
+        splice_search = self.matrix_probability.xs(tuple(signal_decisions.values()),
-                                                       level=list(signalDecisions.keys())
+                                                       level=list(signal_decisions.keys())
                                                       )
-        ans['probability'] = spliceSearch.to_dict('records')[0]
+        ans['probability'] = splice_search.to_dict('records')[0]
-        ans['trande'] = spliceSearch.iloc[0].idxmax()
+        ans['trande'] = splice_search.iloc[0].idxmax()
         return ans
 
-    #получение матриц вероятностей и суммы в видей словарей
+    # Get probability and sum matrices as dictionaries
-    def getMatrixDict(self) -> dict:
+    def get_matrix_dict(self) -> dict:
         ans = {}
-        ans['amounts'] = self.matrixAmounts.to_dict('tight')
+        ans['amounts'] = self.matrix_amounts.to_dict('tight')
-        ans['probability'] = self.matrixProbability.to_dict('tight')
+        ans['probability'] = self.matrix_probability.to_dict('tight')
         return ans
 
-    #установка матриц вероятностей и суммы в видей словарей
+    # Set probability and sum matrices from dictionaries
-    def setMatrixDict(self,matrixDict: dict) -> dict:
+    def set_matrix_dict(self, matrix_dict: dict) -> dict:
-        if matrixDict['amounts'] != None:
+        if matrix_dict['amounts'] != None:
-            self.matrixAmounts = pd.DataFrame.from_dict(y['amounts'], orient='tight')
+            self.matrix_amounts = pd.DataFrame.from_dict(y['amounts'], orient='tight')
-        if matrixDict['probability'] != None:
+        if matrix_dict['probability'] != None:
-            self.matrixProbability = pd.DataFrame.from_dict(y['probability'], orient='tight') 
+            self.matrix_probability = pd.DataFrame.from_dict(y['probability'], orient='tight')
-        
-        
-
-    
-    
-    
-    
-
-        

market_trade/tests/test_decision.py

@@ -1,10 +1,10 @@
-from market_trade.core.decisionManager_v2 import *
+from market_trade.core.decisionManager_v2 import DecisionManager
-from market_trade.core.indicators_v2 import *
+from market_trade.core.indicators_v2 import ind_BB
-from market_trade.core.signals_v2 import *
+from market_trade.core.signals_v2 import sig_BB
 import market_trade.data.dataloader
 
 
-sigAgrReq = {
+sig_agr_req = {
     'sig_BB': {
         'className': sig_BB,
         'params': {'source': 'close', 'target': 'close'},
@@ -27,14 +27,15 @@ sigAgrReq = {
     }
 }
 
-test = decsionManager('Pipa', sigAgrReq)
+test = DecisionManager('Pipa', sig_agr_req)
 
 
 import pandas as pd
 
 df_candle = pd.read_csv("../../data/EURUSD_price_candlestick.csv")
 df_candle["date"] = df_candle["timestamp"]
-sigAgrRetroTemplate = {
+
+sig_agr_retro_template = {
     'sig_BB': {
         'signalData': None,
         'indicatorData': {'ind_BB': None}
@@ -45,11 +46,11 @@ sigAgrRetroTemplate = {
     }
 }
 
-retroAns = test.getRetroTrendAns(sigAgrRetroTemplate,df_candle[5000:6000].reset_index(drop=True),40)
+retro_ans = test.get_retro_trend_answer(sig_agr_retro_template, df_candle[5000:6000].reset_index(drop=True), 40)
 
-test.generateMatrixProbabilityFromDict(retroAns)
+test.generate_matrix_probability_from_dict(retro_ans)
 
-sigAgrData = {
+sig_agr_data = {
     'sig_BB': {
         'signalData': df_candle[990:1000],
         'indicatorData': {'ind_BB': df_candle[:1000]}
@@ -60,4 +61,4 @@ sigAgrData = {
     }
 }
 
-test.getOnlineAns(sigAgrData, 0.0)
+test.get_online_answer(sig_agr_data, 0.0)

pyproject.toml

@@ -26,5 +26,5 @@ nbconvert = "^7.16.2"
 [tool.poetry.dev-dependencies]
 
 [build-system]
-requires = ["poetry-core>=1.0.0"]
+requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

tools/t.py

@@ -0,0 +1,13 @@
+import tinkoff_grpc
+import market_trade.constants
+
+api_address = market_trade.constants.TINKOFF_API_ADDRESS
+token = market_trade.constants.TINKOFF_BEARER_TOKEN
+authorization_field = market_trade.constants.TINKOFF_AUTHORIZATION_HEADER
+with tinkoff_grpc.Channel(api_address=api_address,
+                          token=token,
+                          authorization_field=authorization_field) as tinkoff_channel:
+    instrument_service = tinkoff_grpc.InstrumentsService(tinkoff_channel)
+    currencies = instrument_service.get_currencies(market_trade.constants.DEFAULT_INSTRUMENT_STATUS)
+    for currency in currencies:
+        print(currency.figi, currency.iso_code)

uv.lock

@@ -0,0 +1,3 @@
+version = 1
+revision = 3
+requires-python = ">=3.14"