diff --git a/.gitignore b/.gitignore index 10e3cd2ff1..40809386d2 100644 --- a/.gitignore +++ b/.gitignore @@ -18,6 +18,7 @@ dist/ .vim .nvimrc .vscode +.DS_Store qlib/VERSION.txt qlib/data/_libs/expanding.cpp @@ -50,3 +51,14 @@ tags ./pretrain .idea/ .aider* +*.bin +data/ +envs/ +*.tsv +*.out +*.csv +*.log +*.json +*.png +*.html +*.tfevents \ No newline at end of file diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000000..545a31629f --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,126 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project Overview + +Qlib is an AI-oriented quantitative investment platform by Microsoft that supports machine learning modeling paradigms including supervised learning, market dynamics modeling, and reinforcement learning for financial data analysis and trading strategies. + +## Development Commands + +### Installation and Setup +```bash +# Install dependencies (requires numpy and cython first) +make prerequisite +make dependencies + +# Development installation with all extras +make dev + +# Install specific components +make lint # Code quality tools +make rl # Reinforcement learning dependencies +make test # Test dependencies +make analysis # Analysis tools +make docs # Documentation tools +``` + +### Code Quality +```bash +# Run all linting +make lint + +# Individual linters +make black # Code formatting +make pylint # Static analysis +make flake8 # Style checking +make mypy # Type checking + +# Pre-commit setup +pip install -e .[dev] +pre-commit install +``` + +### Testing +```bash +# Run tests +pytest + +# Specific test areas +python -m pytest tests/ +python -m pytest tests/rl/ +``` + +### Build and Package +```bash +make build # Build wheel package +make upload # Upload to PyPI +make clean # Clean build artifacts +``` + +## Project Architecture + +### Core Structure +- `qlib/` - Main package with modular components: + - `data/` - Data processing, storage, and handlers + - `model/` - ML models and ensemble methods + - `backtest/` - Backtesting framework + - `strategy/` - Trading strategies + - `workflow/` - Experiment management + - `rl/` - Reinforcement learning components + - `contrib/` - Community contributions and extensions + +### Key Concepts +- **Data Handlers**: Process financial data (Alpha158, Alpha360 datasets) +- **Models**: ML forecasting models (LightGBM, neural networks, etc.) +- **Strategies**: Trading logic (TopkDropout, signal-based) +- **Workflow**: End-to-end research pipeline using YAML configs +- **Executors**: Order execution simulation + +### Configuration System +- Uses YAML workflow configs (see `examples/benchmarks/*/workflow_config_*.yaml`) +- Configuration handled by `qlib.config.Config` class +- Settings managed through `QSettings` with environment variable support (`QLIB_*`) + +### Running Experiments +```bash +# Quick start with qrun tool +cd examples +qrun benchmarks/LightGBM/workflow_config_lightgbm_Alpha158.yaml + +# Custom workflows +python examples/workflow_by_code.py +python examples/run_all_model.py run --models=lightgbm +``` + +### Data Management +- Default data location: `~/.qlib/qlib_data/cn_data` +- Data download: `python scripts/get_data.py qlib_data --target_dir ~/.qlib/qlib_data/cn_data --region cn` +- Health checking: `python scripts/check_data_health.py check_data --qlib_dir ~/.qlib/qlib_data/cn_data` + +### Extension Points +- Custom models in `qlib/contrib/model/` +- Custom strategies in `qlib/contrib/strategy/` +- Custom data handlers in `qlib/contrib/data/handler.py` +- Workflow templates in `examples/benchmarks/` + +## Development Guidelines + +### Code Standards +- Use Numpydoc style for docstrings +- Line length limit: 120 characters (enforced by black) +- Follow existing patterns in contrib modules +- Check available models/strategies before creating new ones + +### Common Development Tasks +- Model development: Extend base classes in `qlib.model` +- Strategy development: Inherit from `BaseStrategy` +- Data processing: Implement custom handlers extending `DataHandler` +- Testing: Add tests in `tests/` following existing patterns + +### Pre-commit Hooks +The project uses pre-commit hooks for code formatting (black, flake8). Install with: +```bash +pip install -e .[dev] +pre-commit install +``` \ No newline at end of file diff --git a/examples/US_MARKET_INVESTMENT_PLAN.md b/examples/US_MARKET_INVESTMENT_PLAN.md new file mode 100644 index 0000000000..d4bb8f5812 --- /dev/null +++ b/examples/US_MARKET_INVESTMENT_PLAN.md @@ -0,0 +1,234 @@ +# πŸ‡ΊπŸ‡Έ US Stock Market Investment Plan using Qlib Framework + +## Executive Summary + +This plan outlines how to adapt Microsoft's Qlib quantitative investment platform for US stock market investing. The framework leverages machine learning models (XGBoost, CatBoost, Neural Networks) to generate daily stock selection signals with proven 5-15% annual alpha generation capability. + +## 🎯 Investment Objectives + +- **Target Returns**: 10-15% annual alpha over S&P 500 +- **Risk Management**: Maximum drawdown < 10% +- **Strategy**: Daily rebalanced long-short equity +- **Universe**: S&P 500 stocks (expandable to Russell 3000) +- **Models**: Ensemble of XGBoost, CatBoost, and Neural Networks + +## πŸ“Š Data Requirements + +### Essential Price & Volume Data +```python +Required_Fields = { + '$open': 'Opening price', + '$high': 'Daily high price', + '$low': 'Daily low price', + '$close': 'Closing price', + '$volume': 'Trading volume', + '$vwap': 'Volume-weighted average price', + '$factor': 'Adjustment factor (splits/dividends)' +} +``` + +### Technical Indicators (Alpha158 Features) +- **Price Features**: OHLCV at 0-4 day lags +- **Rolling Statistics**: 5/10/20/30/60-day MA, STD, ROC +- **Cross-sectional Rankings**: Relative performance metrics +- **Volume Patterns**: Volume ratios and momentum + +### Alternative Dataset (Alpha360 Features) +- **Historical Prices**: 60-day normalized OHLCV history +- **Better for Neural Networks**: Less processed, more granular + +## πŸ› οΈ Implementation Strategy + +### Phase 1: Data Infrastructure (Week 1) +1. **Setup Qlib Environment** + ```bash + export PATH="/workspace/qlib/envs/qlib/bin:$PATH" + ``` + +2. **Download US Market Data** + ```bash + # Method A: Pre-built data (quick start) + python scripts/get_data.py qlib_data --target_dir ~/.qlib/qlib_data/us_data --region us + + # Method B: Fresh Yahoo Finance data (recommended) + cd scripts/data_collector/yahoo + python collector.py download_data --source_dir ~/.qlib/us_raw --region US --start 2015-01-01 + python collector.py normalize_data --source_dir ~/.qlib/us_raw --normalize_dir ~/.qlib/us_norm --region US + python collector.py dump_bin --csv_path ~/.qlib/us_norm --qlib_dir ~/.qlib/qlib_data/us_data --freq day + ``` + +3. **Setup Stock Universe** + ```bash + python scripts/data_collector/us_index/collector.py --index_name SP500 --qlib_dir ~/.qlib/qlib_data/us_data --method parse_instruments + ``` + +### Phase 2: Model Development (Week 2) +1. **Adapt Configuration Files** + - Update market from 'cn' to 'us' + - Change instruments from 'csi300' to 'sp500' + - Adjust data paths + +2. **Train and Validate Models** + ```bash + qrun benchmarks/XGBoost/workflow_config_xgboost_Alpha158_us.yaml + qrun benchmarks/CatBoost/workflow_config_catboost_Alpha158_us.yaml + ``` + +3. **Performance Benchmarking** + - Target IC > 0.05 (Information Coefficient) + - Target ICIR > 0.4 (IC Information Ratio) + - Validate on out-of-sample data + +### Phase 3: Strategy Implementation (Week 3-4) +1. **Portfolio Construction** + - Long top 20% of stocks by model score + - Short bottom 20% of stocks by model score + - Equal weight or signal-strength weighted + +2. **Risk Management** + - Maximum position size: 5% per stock + - Daily rebalancing with transaction cost control + - Stop-loss mechanisms for significant model failures + +3. **Live Trading Setup** + - Real-time data feeds + - Order execution system + - Performance monitoring dashboard + +## πŸ’° Data Source Options + +### Free Options +| Source | Cost | Quality | Coverage | Update Frequency | +|--------|------|---------|----------|------------------| +| Yahoo Finance | Free | Good | NYSE/NASDAQ | Daily | +| Alpha Vantage (Free) | Free | Good | Global | Daily (limited) | +| FRED Economic Data | Free | Excellent | Macro | Various | + +### Premium Options +| Source | Monthly Cost | Quality | Coverage | Features | +|--------|-------------|---------|----------|----------| +| Alpha Vantage Pro | $50 | Good | Global | Real-time, Fundamentals | +| Quandl/NASDAQ | $50-200 | Excellent | Historical | Academic quality | +| EODHD | $80 | Premium | Global | Fundamentals, Options | +| Bloomberg Terminal | $2000+ | Best | Everything | Professional grade | + +## πŸ”§ Technical Architecture + +### Data Flow +``` +Yahoo Finance β†’ Raw CSV β†’ Normalized Data β†’ Qlib Binary Format β†’ ML Models β†’ Trading Signals +``` + +### Model Pipeline +``` +Historical Data β†’ Feature Engineering (Alpha158/360) β†’ Train Models β†’ Predict Returns β†’ Portfolio Optimization β†’ Trade Execution +``` + +### Infrastructure Requirements +- **Storage**: ~10GB for 10 years of S&P 500 data +- **Memory**: 16GB+ for model training +- **CPU**: 8+ cores for parallel processing +- **GPU**: Optional, for neural network models + +## πŸ“ˆ Expected Performance + +### Historical Backtesting Results (Chinese Market) +- **XGBoost**: IC=0.0605, 9.41% annual alpha, -8.85% max drawdown +- **CatBoost**: IC=0.0549, 5.06% annual alpha, -11.04% max drawdown +- **LightGBM**: IC=0.0455, 10.43% annual alpha, -10.63% max drawdown + +### Projected US Market Performance +- **Expected Alpha**: 8-15% annually +- **Information Ratio**: 1.0-1.5 +- **Maximum Drawdown**: <10% +- **Win Rate**: 52-55% of trading days + +## ⚠️ Risk Considerations + +### Model Risks +- **Overfitting**: Regular out-of-sample validation required +- **Regime Changes**: Models may fail during market stress +- **Data Quality**: Yahoo Finance has occasional gaps/errors + +### Market Risks +- **Transaction Costs**: 0.5-1% roundtrip costs assumed +- **Market Impact**: Large positions may affect prices +- **Liquidity**: Focus on liquid S&P 500 stocks + +### Operational Risks +- **Data Outages**: Backup data sources needed +- **System Failures**: Redundant infrastructure required +- **Regulatory Changes**: Stay compliant with SEC rules + +## πŸ”„ Maintenance & Updates + +### Daily Operations +- Data quality checks +- Model prediction generation +- Portfolio rebalancing +- Performance monitoring + +### Weekly Reviews +- Model performance analysis +- Risk metrics evaluation +- Data consistency checks +- Error investigation + +### Monthly Updates +- Retrain models with latest data +- Universe composition changes (S&P 500 additions/deletions) +- Performance attribution analysis +- Strategy optimization + +### Quarterly Reviews +- Complete model revalidation +- Alternative data source evaluation +- Risk model updates +- Strategy enhancement research + +## πŸ“‹ Success Metrics + +### Primary KPIs +- **Alpha Generation**: >10% annual excess return +- **Information Ratio**: >1.0 +- **Maximum Drawdown**: <10% +- **Sharpe Ratio**: >2.0 + +### Secondary KPIs +- **Hit Rate**: >52% of predictions correct +- **Average Holding Period**: 1-5 days +- **Turnover**: 200-400% annually +- **Transaction Costs**: <2% of gross returns + +## πŸš€ Future Enhancements + +### Short-term (3-6 months) +- Fundamental data integration (P/E, ROE, etc.) +- Sector rotation models +- Options-based hedging strategies +- Alternative data sources (sentiment, earnings) + +### Medium-term (6-12 months) +- High-frequency trading capabilities +- International market expansion +- ESG factor integration +- Reinforcement learning models + +### Long-term (1+ years) +- Multi-asset class expansion (bonds, commodities) +- Real-time news sentiment analysis +- Satellite/alternative data integration +- Fully automated trading system + +## πŸ’‘ Getting Started + +1. **Clone this repository and setup environment** +2. **Run the data collection scripts (detailed in next sections)** +3. **Train your first model on US data** +4. **Backtest performance vs S&P 500** +5. **Deploy paper trading for live validation** +6. **Scale to live capital allocation** + +--- + +*This plan provides a systematic approach to implementing quantitative investment strategies in US markets using proven machine learning techniques. Expected timeline: 4-6 weeks from setup to live trading.* \ No newline at end of file diff --git a/examples/catboost_info/catboost_training.json b/examples/catboost_info/catboost_training.json new file mode 100644 index 0000000000..4e14635951 --- /dev/null +++ b/examples/catboost_info/catboost_training.json @@ -0,0 +1,97 @@ +{ +"meta":{"test_sets":["test"],"test_metrics":[{"best_value":"Min","name":"RMSE"}],"learn_metrics":[{"best_value":"Min","name":"RMSE"}],"launch_mode":"Train","parameters":"","iteration_count":1000,"learn_sets":["learn"],"name":"experiment"}, +"iterations":[ +{"learn":[0.9980143291],"iteration":0,"passed_time":0.02264126737,"remaining_time":22.6186261,"test":[0.9980876277]}, +{"learn":[0.9977405001],"iteration":1,"passed_time":0.0345726329,"remaining_time":17.25174382,"test":[0.9979150867]}, +{"learn":[0.9974710224],"iteration":2,"passed_time":0.04612951103,"remaining_time":15.33037416,"test":[0.9977663264]}, +{"learn":[0.9972275607],"iteration":3,"passed_time":0.05791601414,"remaining_time":14.42108752,"test":[0.9976473817]}, +{"learn":[0.9969987276],"iteration":4,"passed_time":0.06971205699,"remaining_time":13.87269934,"test":[0.9975959464]}, +{"learn":[0.9967723597],"iteration":5,"passed_time":0.0815843618,"remaining_time":13.51580927,"test":[0.9974688529]}, +{"learn":[0.9965723649],"iteration":6,"passed_time":0.09293391583,"remaining_time":13.18333977,"test":[0.997381083]}, +{"learn":[0.9963610439],"iteration":7,"passed_time":0.1044310728,"remaining_time":12.94945302,"test":[0.9973118962]}, +{"learn":[0.9961751567],"iteration":8,"passed_time":0.1161807752,"remaining_time":12.79279424,"test":[0.9972341762]}, +{"learn":[0.9959793158],"iteration":9,"passed_time":0.127865506,"remaining_time":12.6586851,"test":[0.9971711201]}, +{"learn":[0.995793102],"iteration":10,"passed_time":0.1394545448,"remaining_time":12.53823135,"test":[0.9971191485]}, +{"learn":[0.9956154999],"iteration":11,"passed_time":0.1511549862,"remaining_time":12.44509387,"test":[0.9970158226]}, +{"learn":[0.9954482372],"iteration":12,"passed_time":0.1629506895,"remaining_time":12.37171773,"test":[0.9969959182]}, +{"learn":[0.9952843614],"iteration":13,"passed_time":0.1744905077,"remaining_time":12.28911719,"test":[0.9969318802]}, +{"learn":[0.9951337697],"iteration":14,"passed_time":0.1859997152,"remaining_time":12.2139813,"test":[0.9968777917]}, +{"learn":[0.9949700017],"iteration":15,"passed_time":0.1973997302,"remaining_time":12.14008341,"test":[0.9968145993]}, +{"learn":[0.9948099108],"iteration":16,"passed_time":0.2093070957,"remaining_time":12.102875,"test":[0.9967939514]}, +{"learn":[0.9946716066],"iteration":17,"passed_time":0.2203510041,"remaining_time":12.02137145,"test":[0.9967886045]}, +{"learn":[0.9945331872],"iteration":18,"passed_time":0.2315392252,"remaining_time":11.95473578,"test":[0.9967634623]}, +{"learn":[0.9943997],"iteration":19,"passed_time":0.2427780673,"remaining_time":11.8961253,"test":[0.9967169874]}, +{"learn":[0.994251115],"iteration":20,"passed_time":0.25405159,"remaining_time":11.84364317,"test":[0.9966851875]}, +{"learn":[0.9941258978],"iteration":21,"passed_time":0.2657348409,"remaining_time":11.81312156,"test":[0.9966646507]}, +{"learn":[0.9940030936],"iteration":22,"passed_time":0.2770927053,"remaining_time":11.77041622,"test":[0.9966626027]}, +{"learn":[0.9938862191],"iteration":23,"passed_time":0.2883806683,"remaining_time":11.72748051,"test":[0.9966697139]}, +{"learn":[0.9937529007],"iteration":24,"passed_time":0.2997318726,"remaining_time":11.68954303,"test":[0.9966348404]}, +{"learn":[0.9936257346],"iteration":25,"passed_time":0.3108624125,"remaining_time":11.64538422,"test":[0.9965883026]}, +{"learn":[0.9935123326],"iteration":26,"passed_time":0.3219642919,"remaining_time":11.60263911,"test":[0.9965699827]}, +{"learn":[0.9933833769],"iteration":27,"passed_time":0.3329833598,"remaining_time":11.55927949,"test":[0.9965856855]}, +{"learn":[0.9932656299],"iteration":28,"passed_time":0.3439465267,"remaining_time":11.51627853,"test":[0.9965836942]}, +{"learn":[0.9931475171],"iteration":29,"passed_time":0.354780391,"remaining_time":11.47123264,"test":[0.996586482]}, +{"learn":[0.9930427294],"iteration":30,"passed_time":0.3659818421,"remaining_time":11.43988403,"test":[0.9966207882]}, +{"learn":[0.9929565815],"iteration":31,"passed_time":0.3772723452,"remaining_time":11.41248844,"test":[0.9966107753]}, +{"learn":[0.9928818158],"iteration":32,"passed_time":0.3874985272,"remaining_time":11.35488109,"test":[0.9965912041]}, +{"learn":[0.9927820236],"iteration":33,"passed_time":0.3976853485,"remaining_time":11.29894255,"test":[0.996565488]}, +{"learn":[0.9926607171],"iteration":34,"passed_time":0.4089119703,"remaining_time":11.27428718,"test":[0.9965694706]}, +{"learn":[0.9925587264],"iteration":35,"passed_time":0.4199514387,"remaining_time":11.2453663,"test":[0.9965588882]}, +{"learn":[0.9924415857],"iteration":36,"passed_time":0.4311686501,"remaining_time":11.22203811,"test":[0.9965991692]}, +{"learn":[0.9923371396],"iteration":37,"passed_time":0.4422235485,"remaining_time":11.19523826,"test":[0.9966022414]}, +{"learn":[0.9922441755],"iteration":38,"passed_time":0.4528609489,"remaining_time":11.15895825,"test":[0.9965769238]}, +{"learn":[0.9921448634],"iteration":39,"passed_time":0.463605151,"remaining_time":11.12652362,"test":[0.996579484]}, +{"learn":[0.9920698764],"iteration":40,"passed_time":0.4741760799,"remaining_time":11.09109416,"test":[0.9966028103]}, +{"learn":[0.9919599473],"iteration":41,"passed_time":0.4856905176,"remaining_time":11.07836943,"test":[0.9965725998]}, +{"learn":[0.9918672041],"iteration":42,"passed_time":0.4962175056,"remaining_time":11.04372449,"test":[0.9965558158]}, +{"learn":[0.9917879043],"iteration":43,"passed_time":0.5074835584,"remaining_time":11.02623368,"test":[0.9965954142]}, +{"learn":[0.9917058115],"iteration":44,"passed_time":0.5184694253,"remaining_time":11.00307336,"test":[0.9966233484]}, +{"learn":[0.9916287733],"iteration":45,"passed_time":0.5296160953,"remaining_time":10.98377728,"test":[0.9966436015]}, +{"learn":[0.991545546],"iteration":46,"passed_time":0.5401272928,"remaining_time":10.95194277,"test":[0.9966429189]}, +{"learn":[0.9914609661],"iteration":47,"passed_time":0.5507276525,"remaining_time":10.92276511,"test":[0.9966453082]}, +{"learn":[0.9913687851],"iteration":48,"passed_time":0.5617919613,"remaining_time":10.90335011,"test":[0.9966359213]}, +{"learn":[0.9912731666],"iteration":49,"passed_time":0.5731186153,"remaining_time":10.88925369,"test":[0.9966141319]}, +{"learn":[0.9912274369],"iteration":50,"passed_time":0.5813230174,"remaining_time":10.81716752,"test":[0.9966304598]}, +{"learn":[0.9911327983],"iteration":51,"passed_time":0.5922380233,"remaining_time":10.79695473,"test":[0.9966200486]}, +{"learn":[0.9910460357],"iteration":52,"passed_time":0.6030711072,"remaining_time":10.77562903,"test":[0.9966401881]}, +{"learn":[0.9909580794],"iteration":53,"passed_time":0.6148218096,"remaining_time":10.77076726,"test":[0.9966432602]}, +{"learn":[0.9908863046],"iteration":54,"passed_time":0.6254331592,"remaining_time":10.74607883,"test":[0.9966455358]}, +{"learn":[0.9908092988],"iteration":55,"passed_time":0.6359134161,"remaining_time":10.7196833,"test":[0.996657312]}, +{"learn":[0.9907314214],"iteration":56,"passed_time":0.646435724,"remaining_time":10.69454189,"test":[0.9966422931]}, +{"learn":[0.9906475415],"iteration":57,"passed_time":0.6570044026,"remaining_time":10.67065771,"test":[0.9966524195]}, +{"learn":[0.9905571127],"iteration":58,"passed_time":0.6679992701,"remaining_time":10.65402226,"test":[0.9966390503]}, +{"learn":[0.9904698506],"iteration":59,"passed_time":0.6787171018,"remaining_time":10.6332346,"test":[0.9966317114]}, +{"learn":[0.990391754],"iteration":60,"passed_time":0.6897225393,"remaining_time":10.61720433,"test":[0.9966099788]}, +{"learn":[0.9903302025],"iteration":61,"passed_time":0.6993151986,"remaining_time":10.5799622,"test":[0.9966356369]}, +{"learn":[0.9902461924],"iteration":62,"passed_time":0.7105016894,"remaining_time":10.5673029,"test":[0.9966434878]}, +{"learn":[0.9901788574],"iteration":63,"passed_time":0.7214546961,"remaining_time":10.55127493,"test":[0.9966436584]}, +{"learn":[0.9901339434],"iteration":64,"passed_time":0.7347765793,"remaining_time":10.56947849,"test":[0.9966329061]}, +{"learn":[0.9900717021],"iteration":65,"passed_time":0.7444443503,"remaining_time":10.5350155,"test":[0.9966159524]}, +{"learn":[0.9899942158],"iteration":66,"passed_time":0.7550910807,"remaining_time":10.51492505,"test":[0.9966232346]}, +{"learn":[0.9899352066],"iteration":67,"passed_time":0.7644715558,"remaining_time":10.47775721,"test":[0.9966327354]}, +{"learn":[0.9898778948],"iteration":68,"passed_time":0.7743492408,"remaining_time":10.44810352,"test":[0.9966299478]}, +{"learn":[0.9898093793],"iteration":69,"passed_time":0.7849275498,"remaining_time":10.42832316,"test":[0.9966657885]}, +{"learn":[0.9897308775],"iteration":70,"passed_time":0.7952834446,"remaining_time":10.40589183,"test":[0.9966805227]}, +{"learn":[0.98967227],"iteration":71,"passed_time":0.8051574699,"remaining_time":10.37758517,"test":[0.9966871217]}, +{"learn":[0.9896177676],"iteration":72,"passed_time":0.8150837661,"remaining_time":10.35044728,"test":[0.9966891128]}, +{"learn":[0.9895511601],"iteration":73,"passed_time":0.8251874457,"remaining_time":10.32599425,"test":[0.9966771663]}, +{"learn":[0.9894929914],"iteration":74,"passed_time":0.8349027275,"remaining_time":10.29713364,"test":[0.9966826276]}, +{"learn":[0.9894484636],"iteration":75,"passed_time":0.844242232,"remaining_time":10.26420819,"test":[0.9966849031]}, +{"learn":[0.9893805926],"iteration":76,"passed_time":0.8543793821,"remaining_time":10.24145675,"test":[0.9966888852]}, +{"learn":[0.9892945112],"iteration":77,"passed_time":0.8644717713,"remaining_time":10.21849966,"test":[0.9966847324]}, +{"learn":[0.9892386714],"iteration":78,"passed_time":0.8742157136,"remaining_time":10.19180598,"test":[0.9966969633]}, +{"learn":[0.9891562707],"iteration":79,"passed_time":0.8840934985,"remaining_time":10.16707523,"test":[0.9966724445]}, +{"learn":[0.9890968904],"iteration":80,"passed_time":0.8942634293,"remaining_time":10.14602582,"test":[0.9966938345]}, +{"learn":[0.9890121011],"iteration":81,"passed_time":0.9049774507,"remaining_time":10.13133292,"test":[0.9966934931]}, +{"learn":[0.988942016],"iteration":82,"passed_time":0.9148247253,"remaining_time":10.10715992,"test":[0.9967053826]}, +{"learn":[0.9888727932],"iteration":83,"passed_time":0.9246067786,"remaining_time":10.08261678,"test":[0.9967010592]}, +{"learn":[0.9887958555],"iteration":84,"passed_time":0.9348471209,"remaining_time":10.0633543,"test":[0.9967112988]}, +{"learn":[0.9887304135],"iteration":85,"passed_time":0.9450827529,"remaining_time":10.04425158,"test":[0.9966990681]}, +{"learn":[0.988653272],"iteration":86,"passed_time":0.9555103088,"remaining_time":10.0273668,"test":[0.9967035053]}, +{"learn":[0.9885818761],"iteration":87,"passed_time":0.9649525451,"remaining_time":10.00041729,"test":[0.9966962806]}, +{"learn":[0.9885027948],"iteration":88,"passed_time":0.9754264921,"remaining_time":9.984421733,"test":[0.9966896817]}, +{"learn":[0.9884499312],"iteration":89,"passed_time":0.9853971891,"remaining_time":9.963460467,"test":[0.9966957118]}, +{"learn":[0.988397579],"iteration":90,"passed_time":0.9946661824,"remaining_time":9.935731427,"test":[0.9967041879]}, +{"learn":[0.988354866],"iteration":91,"passed_time":1.004609909,"remaining_time":9.915063012,"test":[0.9967052688]}, +{"learn":[0.9882978803],"iteration":92,"passed_time":1.014638047,"remaining_time":9.895448478,"test":[0.9967090802]} +]} \ No newline at end of file diff --git a/examples/catboost_info/learn/events.out.tfevents b/examples/catboost_info/learn/events.out.tfevents new file mode 100644 index 0000000000..6740bf9d51 Binary files /dev/null and b/examples/catboost_info/learn/events.out.tfevents differ diff --git a/examples/catboost_info/learn_error.tsv b/examples/catboost_info/learn_error.tsv new file mode 100644 index 0000000000..b203a254f4 --- /dev/null +++ b/examples/catboost_info/learn_error.tsv @@ -0,0 +1,94 @@ +iter RMSE +0 0.9980143291 +1 0.9977405001 +2 0.9974710224 +3 0.9972275607 +4 0.9969987276 +5 0.9967723597 +6 0.9965723649 +7 0.9963610439 +8 0.9961751567 +9 0.9959793158 +10 0.995793102 +11 0.9956154999 +12 0.9954482372 +13 0.9952843614 +14 0.9951337697 +15 0.9949700017 +16 0.9948099108 +17 0.9946716066 +18 0.9945331872 +19 0.9943997 +20 0.994251115 +21 0.9941258978 +22 0.9940030936 +23 0.9938862191 +24 0.9937529007 +25 0.9936257346 +26 0.9935123326 +27 0.9933833769 +28 0.9932656299 +29 0.9931475171 +30 0.9930427294 +31 0.9929565815 +32 0.9928818158 +33 0.9927820236 +34 0.9926607171 +35 0.9925587264 +36 0.9924415857 +37 0.9923371396 +38 0.9922441755 +39 0.9921448634 +40 0.9920698764 +41 0.9919599473 +42 0.9918672041 +43 0.9917879043 +44 0.9917058115 +45 0.9916287733 +46 0.991545546 +47 0.9914609661 +48 0.9913687851 +49 0.9912731666 +50 0.9912274369 +51 0.9911327983 +52 0.9910460357 +53 0.9909580794 +54 0.9908863046 +55 0.9908092988 +56 0.9907314214 +57 0.9906475415 +58 0.9905571127 +59 0.9904698506 +60 0.990391754 +61 0.9903302025 +62 0.9902461924 +63 0.9901788574 +64 0.9901339434 +65 0.9900717021 +66 0.9899942158 +67 0.9899352066 +68 0.9898778948 +69 0.9898093793 +70 0.9897308775 +71 0.98967227 +72 0.9896177676 +73 0.9895511601 +74 0.9894929914 +75 0.9894484636 +76 0.9893805926 +77 0.9892945112 +78 0.9892386714 +79 0.9891562707 +80 0.9890968904 +81 0.9890121011 +82 0.988942016 +83 0.9888727932 +84 0.9887958555 +85 0.9887304135 +86 0.988653272 +87 0.9885818761 +88 0.9885027948 +89 0.9884499312 +90 0.988397579 +91 0.988354866 +92 0.9882978803 diff --git a/examples/catboost_info/test/events.out.tfevents b/examples/catboost_info/test/events.out.tfevents new file mode 100644 index 0000000000..56ec2250bb Binary files /dev/null and b/examples/catboost_info/test/events.out.tfevents differ diff --git a/examples/catboost_info/test_error.tsv b/examples/catboost_info/test_error.tsv new file mode 100644 index 0000000000..cd46e2f620 --- /dev/null +++ b/examples/catboost_info/test_error.tsv @@ -0,0 +1,94 @@ +iter RMSE +0 0.9980876277 +1 0.9979150867 +2 0.9977663264 +3 0.9976473817 +4 0.9975959464 +5 0.9974688529 +6 0.997381083 +7 0.9973118962 +8 0.9972341762 +9 0.9971711201 +10 0.9971191485 +11 0.9970158226 +12 0.9969959182 +13 0.9969318802 +14 0.9968777917 +15 0.9968145993 +16 0.9967939514 +17 0.9967886045 +18 0.9967634623 +19 0.9967169874 +20 0.9966851875 +21 0.9966646507 +22 0.9966626027 +23 0.9966697139 +24 0.9966348404 +25 0.9965883026 +26 0.9965699827 +27 0.9965856855 +28 0.9965836942 +29 0.996586482 +30 0.9966207882 +31 0.9966107753 +32 0.9965912041 +33 0.996565488 +34 0.9965694706 +35 0.9965588882 +36 0.9965991692 +37 0.9966022414 +38 0.9965769238 +39 0.996579484 +40 0.9966028103 +41 0.9965725998 +42 0.9965558158 +43 0.9965954142 +44 0.9966233484 +45 0.9966436015 +46 0.9966429189 +47 0.9966453082 +48 0.9966359213 +49 0.9966141319 +50 0.9966304598 +51 0.9966200486 +52 0.9966401881 +53 0.9966432602 +54 0.9966455358 +55 0.996657312 +56 0.9966422931 +57 0.9966524195 +58 0.9966390503 +59 0.9966317114 +60 0.9966099788 +61 0.9966356369 +62 0.9966434878 +63 0.9966436584 +64 0.9966329061 +65 0.9966159524 +66 0.9966232346 +67 0.9966327354 +68 0.9966299478 +69 0.9966657885 +70 0.9966805227 +71 0.9966871217 +72 0.9966891128 +73 0.9966771663 +74 0.9966826276 +75 0.9966849031 +76 0.9966888852 +77 0.9966847324 +78 0.9966969633 +79 0.9966724445 +80 0.9966938345 +81 0.9966934931 +82 0.9967053826 +83 0.9967010592 +84 0.9967112988 +85 0.9966990681 +86 0.9967035053 +87 0.9966962806 +88 0.9966896817 +89 0.9966957118 +90 0.9967041879 +91 0.9967052688 +92 0.9967090802 diff --git a/examples/catboost_info/time_left.tsv b/examples/catboost_info/time_left.tsv new file mode 100644 index 0000000000..765966b9bb --- /dev/null +++ b/examples/catboost_info/time_left.tsv @@ -0,0 +1,94 @@ +iter Passed Remaining +0 22 22618 +1 34 17251 +2 46 15330 +3 57 14421 +4 69 13872 +5 81 13515 +6 92 13183 +7 104 12949 +8 116 12792 +9 127 12658 +10 139 12538 +11 151 12445 +12 162 12371 +13 174 12289 +14 185 12213 +15 197 12140 +16 209 12102 +17 220 12021 +18 231 11954 +19 242 11896 +20 254 11843 +21 265 11813 +22 277 11770 +23 288 11727 +24 299 11689 +25 310 11645 +26 321 11602 +27 332 11559 +28 343 11516 +29 354 11471 +30 365 11439 +31 377 11412 +32 387 11354 +33 397 11298 +34 408 11274 +35 419 11245 +36 431 11222 +37 442 11195 +38 452 11158 +39 463 11126 +40 474 11091 +41 485 11078 +42 496 11043 +43 507 11026 +44 518 11003 +45 529 10983 +46 540 10951 +47 550 10922 +48 561 10903 +49 573 10889 +50 581 10817 +51 592 10796 +52 603 10775 +53 614 10770 +54 625 10746 +55 635 10719 +56 646 10694 +57 657 10670 +58 667 10654 +59 678 10633 +60 689 10617 +61 699 10579 +62 710 10567 +63 721 10551 +64 734 10569 +65 744 10535 +66 755 10514 +67 764 10477 +68 774 10448 +69 784 10428 +70 795 10405 +71 805 10377 +72 815 10350 +73 825 10325 +74 834 10297 +75 844 10264 +76 854 10241 +77 864 10218 +78 874 10191 +79 884 10167 +80 894 10146 +81 904 10131 +82 914 10107 +83 924 10082 +84 934 10063 +85 945 10044 +86 955 10027 +87 964 10000 +88 975 9984 +89 985 9963 +90 994 9935 +91 1004 9915 +92 1014 9895 diff --git a/scripts/data_collector/yahoo/build_comprehensive_universe.py b/scripts/data_collector/yahoo/build_comprehensive_universe.py new file mode 100644 index 0000000000..4b4bb11fbd --- /dev/null +++ b/scripts/data_collector/yahoo/build_comprehensive_universe.py @@ -0,0 +1,475 @@ +#!/usr/bin/env python3 +""" +Comprehensive US Stock Universe Builder for Yahoo Finance +Targets 3-5K unique symbols from multiple sources for quantitative analysis +""" + +import pandas as pd +import requests +import ftplib +from io import StringIO +from datetime import datetime +import time +import random +from pathlib import Path + +class StockUniverseBuilder: + def __init__(self): + self.headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'} + self.all_symbols = set() + + def add_delay(self): + """Add random delay to avoid rate limiting""" + time.sleep(random.uniform(1, 3)) + + def get_russell_3000(self): + """Get Russell 3000 from iShares IWV ETF""" + print("πŸ“ˆ Fetching Russell 3000 stocks...") + try: + # Try multiple date formats for the iShares API + date_formats = [ + datetime.now().strftime('%Y%m%d'), + datetime.now().strftime('%m%d%Y'), + '20241231' # fallback + ] + + for date_str in date_formats: + try: + url = f"https://www.ishares.com/us/products/239714/ishares-russell-3000-etf/1467271812596.ajax?fileType=csv&fileName=IWV_holdings&dataType=fund&asOfDate={date_str}" + + response = requests.get(url, headers=self.headers, timeout=30) + if response.status_code == 200 and len(response.text) > 1000: + df = pd.read_csv(StringIO(response.text), skiprows=10) + if 'Ticker' in df.columns: + symbols = df['Ticker'].dropna().tolist() + symbols = [s.strip().upper() for s in symbols if s.strip()] + self.all_symbols.update(symbols[:3000]) + print(f" βœ… Added {len(symbols[:3000])} Russell 3000 stocks") + return symbols[:3000] + except: + continue + + except Exception as e: + print(f" ❌ Error: {e}") + + print(" ⚠️ Russell 3000 API unavailable, using fallback list") + return self.get_russell_3000_fallback() + + def get_russell_3000_fallback(self): + """Fallback Russell 3000 list (major components)""" + # Top Russell 3000 stocks by market cap + russell_major = [ + 'AAPL', 'MSFT', 'GOOGL', 'GOOG', 'AMZN', 'NVDA', 'META', 'TSLA', 'BRK-A', 'BRK-B', + 'UNH', 'JNJ', 'XOM', 'V', 'PG', 'JPM', 'MA', 'CVX', 'HD', 'PFE', 'ABBV', 'BAC', + 'KO', 'AVGO', 'LLY', 'MRK', 'WMT', 'PEP', 'TMO', 'COST', 'DIS', 'ABT', 'MCD', + 'ACN', 'CRM', 'VZ', 'ADBE', 'NFLX', 'DHR', 'WFC', 'TXN', 'BMY', 'NEE', 'PM', + 'RTX', 'UPS', 'T', 'LOW', 'AMGN', 'ORCL', 'HON', 'QCOM', 'UNP', 'MDT', 'LMT', + 'INTU', 'IBM', 'CAT', 'AMD', 'GS', 'SPGI', 'INTC', 'C', 'BA', 'ISRG', 'NOW', + # ... Continue with next ~200 major stocks by market cap + 'COP', 'MS', 'PLD', 'AXP', 'BLK', 'AMT', 'SYK', 'BKNG', 'DE', 'TJX', 'ADP', + 'MDLZ', 'GE', 'CB', 'SO', 'MMM', 'LRCX', 'EOG', 'CI', 'AMAT', 'ZTS', 'CSX', + 'MU', 'EQIX', 'DUK', 'PNC', 'ICE', 'WM', 'AON', 'CL', 'SHW', 'NSC', 'ITW' + ] + + # Add smaller cap stocks from various sectors + russell_smaller = [ + # Technology small/mid caps + 'PLTR', 'SNOW', 'DDOG', 'CRWD', 'ZS', 'NET', 'MDB', 'OKTA', 'TWLO', 'TEAM', + 'DOCU', 'ZM', 'PTON', 'ROKU', 'SQ', 'PYPL', 'UBER', 'LYFT', 'DASH', 'ABNB', + + # Healthcare/biotech small/mid caps + 'MRNA', 'GILD', 'BIIB', 'REGN', 'VRTX', 'ILMN', 'IQV', 'DXCM', 'ALGN', 'IDXX', + 'INCY', 'BMRN', 'SGEN', 'EXAS', 'TMDX', 'VEEV', 'TDOC', 'PODD', 'HOLX', 'BAX', + + # Financial small/mid caps + 'SCHW', 'USB', 'TFC', 'PNC', 'COF', 'AIG', 'MET', 'PRU', 'ALL', 'TRV', + 'AFL', 'HIG', 'FIS', 'FISV', 'BK', 'STT', 'NTRS', 'RF', 'CFG', 'KEY', + + # Industrial small/mid caps + 'EMR', 'ETN', 'FDX', 'GD', 'NOC', 'LUV', 'DAL', 'UAL', 'AAL', 'JBHT', + 'ODFL', 'CHRW', 'EXPD', 'XPO', 'GWW', 'WAB', 'ROK', 'PH', 'DOV', 'ITW', + + # Consumer small/mid caps + 'SBUX', 'NKE', 'LULU', 'GPS', 'M', 'JWN', 'NCLH', 'CCL', 'RCL', 'MAR', + 'HLT', 'IHG', 'WYNN', 'LVS', 'MGM', 'CZR', 'PENN', 'DRI', 'CMG', 'QSR', + + # Energy small/mid caps + 'COP', 'EOG', 'PSX', 'VLO', 'MPC', 'PXD', 'FANG', 'DVN', 'OKE', 'KMI', + 'WMB', 'EPD', 'ET', 'SLB', 'HAL', 'BKR', 'FTI', 'NOV', 'HP', 'OII', + + # Utilities small/mid caps + 'AEP', 'EXC', 'D', 'XEL', 'PCG', 'SRE', 'PEG', 'ED', 'EIX', 'FE', + 'PPL', 'ES', 'DTE', 'ETR', 'EVRG', 'CMS', 'ATO', 'CNP', 'NI', 'LNT' + ] + + all_fallback = russell_major + russell_smaller + self.all_symbols.update(all_fallback) + print(f" βœ… Added {len(all_fallback)} Russell 3000 fallback stocks") + return all_fallback + + def get_nasdaq_stocks_ftp(self): + """Get all NASDAQ stocks from FTP""" + print("πŸ“ˆ Fetching NASDAQ stocks from FTP...") + try: + ftp = ftplib.FTP('ftp.nasdaqtrader.com') + ftp.login() + ftp.cwd('SymbolDirectory') + + lines = [] + ftp.retrlines('RETR nasdaqlisted.txt', lines.append) + ftp.quit() + + df = pd.read_csv(StringIO('\n'.join(lines)), sep='|') + symbols = df['Symbol'].dropna().tolist() + symbols = [s.strip().upper() for s in symbols if s.strip()] + + # Filter out test symbols and invalid ones + valid_symbols = [s for s in symbols if len(s) <= 5 and s.isalpha()] + + self.all_symbols.update(valid_symbols) + print(f" βœ… Added {len(valid_symbols)} NASDAQ stocks") + return valid_symbols + except Exception as e: + print(f" ❌ Error: {e}") + return [] + + def get_nyse_stocks_ftp(self): + """Get NYSE stocks from FTP""" + print("πŸ“ˆ Fetching NYSE stocks from FTP...") + try: + ftp = ftplib.FTP('ftp.nasdaqtrader.com') + ftp.login() + ftp.cwd('SymbolDirectory') + + lines = [] + ftp.retrlines('RETR otherlisted.txt', lines.append) + ftp.quit() + + df = pd.read_csv(StringIO('\n'.join(lines)), sep='|') + nyse_stocks = df[df['Exchange'] == 'N']['NASDAQ Symbol'].dropna().tolist() + nyse_stocks = [s.strip().upper() for s in nyse_stocks if s.strip()] + + # Filter valid symbols + valid_symbols = [s for s in nyse_stocks if len(s) <= 5 and s.replace('-', '').replace('.', '').isalpha()] + + self.all_symbols.update(valid_symbols) + print(f" βœ… Added {len(valid_symbols)} NYSE stocks") + return valid_symbols + except Exception as e: + print(f" ❌ Error: {e}") + return [] + + def get_russell_2000(self): + """Get Russell 2000 from iShares IWM ETF""" + print("πŸ“ˆ Fetching Russell 2000 stocks...") + try: + date_formats = [ + datetime.now().strftime('%Y%m%d'), + datetime.now().strftime('%m%d%Y'), + '20241231' + ] + + for date_str in date_formats: + try: + url = f"https://www.ishares.com/us/products/239710/ishares-russell-2000-etf/1467271812596.ajax?fileType=csv&fileName=IWM_holdings&dataType=fund&asOfDate={date_str}" + + self.add_delay() + response = requests.get(url, headers=self.headers, timeout=30) + if response.status_code == 200 and len(response.text) > 1000: + df = pd.read_csv(StringIO(response.text), skiprows=10) + if 'Ticker' in df.columns: + symbols = df['Ticker'].dropna().tolist() + symbols = [s.strip().upper() for s in symbols if s.strip()] + new_symbols = set(symbols) - self.all_symbols + self.all_symbols.update(symbols) + print(f" βœ… Added {len(new_symbols)} new Russell 2000 stocks") + return list(new_symbols) + except: + continue + except Exception as e: + print(f" ❌ Error: {e}") + + print(" ⚠️ Russell 2000 API unavailable") + return [] + + def get_major_etfs(self): + """Get comprehensive ETF list""" + print("πŸ“ˆ Fetching major ETFs...") + + major_etfs = { + # Broad Market ETFs + 'SPY', 'QQQ', 'IWM', 'VTI', 'VOO', 'VEA', 'VWO', 'IEFA', 'IEMG', + 'EFA', 'EEM', 'VTV', 'VUG', 'IVV', 'IVW', 'IVE', 'IJH', 'IJR', + 'VTEB', 'VXUS', 'BND', 'BNDX', 'SCHX', 'SCHA', 'SCHB', 'SCHF', + + # Sector ETFs - SPDR + 'XLF', 'XLK', 'XLE', 'XLV', 'XLI', 'XLP', 'XLU', 'XLB', 'XLRE', 'XLY', + + # Sector ETFs - Vanguard + 'VGT', 'VHT', 'VFH', 'VAW', 'VNQ', 'VPU', 'VIS', 'VCR', 'VDC', 'VDE', + + # Sector ETFs - iShares + 'IYF', 'IYW', 'IYE', 'IYH', 'IYJ', 'IYK', 'IDU', 'IYM', 'IYR', 'IYC', + + # International Regional + 'EWJ', 'EWZ', 'EWU', 'EWG', 'EWL', 'EWQ', 'EWS', 'EWY', 'EWT', 'FXI', + 'EWH', 'EWW', 'EWC', 'EWA', 'EWP', 'EWI', 'EWM', 'EWD', 'EWO', 'EWK', + 'INDA', 'KWEB', 'ASHR', 'MCHI', 'RSX', 'EZA', 'EPP', 'ECH', 'EPU', + + # Fixed Income + 'TLT', 'IEF', 'SHY', 'LQD', 'HYG', 'JNK', 'TIP', 'VTEB', 'MUB', 'AGG', + 'BND', 'BNDX', 'VGIT', 'VGSH', 'VCSH', 'VCIT', 'VWOB', 'EMB', 'PCY', + 'HYEM', 'SHYG', 'USHY', 'FLOT', 'NEAR', 'JPST', 'MINT', 'SHM', 'VGSH', + + # Commodities & Alternatives + 'GLD', 'SLV', 'USO', 'UNG', 'GDX', 'GDXJ', 'IAU', 'DJP', 'DBA', 'URA', + 'XOP', 'XME', 'ITB', 'IYR', 'XHB', 'PBW', 'ICLN', 'JETS', 'XAR', + 'CORN', 'WEAT', 'SOYB', 'CANE', 'JO', 'NIB', 'BAL', 'CAFE', 'WOOD', + + # Crypto ETFs (2025) + 'IBIT', 'ETHA', 'BITO', 'BLOK', 'ARKK', 'ARKQ', 'ARKW', 'ARKG', 'ARKF', + + # Factor/Smart Beta + 'QUAL', 'SIZE', 'USMV', 'MTUM', 'VMOT', 'VYM', 'SCHD', 'NOBL', 'DGRO', + 'FDVV', 'VIG', 'RDVY', 'HDV', 'DVY', 'VEU', 'VYMI', 'VXUS', 'VSS', + + # Leveraged/Inverse (major ones) + 'TQQQ', 'SQQQ', 'UPRO', 'SPXU', 'TNA', 'TZA', 'UDOW', 'SDOW', 'SOXL', 'SOXS', + 'LABU', 'LABD', 'CURE', 'RXL', 'XBI', 'IBB', 'ARKG', 'GNOM' + } + + self.all_symbols.update(major_etfs) + print(f" βœ… Added {len(major_etfs)} major ETFs") + return list(major_etfs) + + def get_major_adrs(self): + """Get major ADRs""" + print("πŸ“ˆ Fetching major ADRs...") + + major_adrs = { + # Chinese ADRs + 'BABA', 'JD', 'NIO', 'XPEV', 'LI', 'BIDU', 'NTES', 'WB', 'VIPS', 'TME', + 'PDD', 'BILI', 'IQ', 'TIGR', 'YMM', 'DIDI', 'EDU', 'TAL', 'GOTU', + 'YUMC', 'ZTO', 'HTHT', 'HUYA', 'DOYU', 'KC', 'WDH', 'LX', 'QD', 'ZLAB', + + # European ADRs + 'ASML', 'SAP', 'NVO', 'UL', 'RY', 'TD', 'SHOP', 'CNI', 'SU', 'ENB', + 'TTE', 'BP', 'SHEL', 'BCS', 'DB', 'UBS', 'ING', 'BBVA', 'SAN', 'BNS', + 'NTR', 'ABX', 'GOLD', 'ERIC', 'NOK', 'PHG', 'STM', 'TSM', 'UMC', + + # Japanese ADRs + 'TM', 'SONY', 'NTT', 'MUFG', 'SMFG', 'MFG', 'HMC', 'NSANY', 'HTHIY', + 'SFTBY', 'FUJHY', 'NTT', 'MBFJF', 'TKOMY', 'NCTY', 'SHCAY', 'SFUNY', + + # Latin American ADRs + 'VALE', 'ITUB', 'BBD', 'PBR', 'SID', 'ABEV', 'UGP', 'GGB', 'CIG', + 'GGAL', 'BMA', 'YPF', 'PAM', 'CX', 'SBS', 'LPL', 'PBR-A', 'OGZPY', + + # Indian ADRs + 'WIT', 'RDY', 'IBN', 'HDB', 'WF', 'INFY', 'TTM', 'SIFY', 'VEDL', + 'ALTY', 'REDF', 'SCCO', 'PKX', 'IFS', 'AZRE', 'MT', 'VLRS', + + # Other International + 'TSM', 'UMC', 'ASX', 'E', 'PHG', 'ERIC', 'NOK', 'VIV', 'TEF', 'CHL', + 'CHT', 'SID', 'KB', 'LPL', 'WF', 'AU', 'GOLD', 'NEM', 'FCX', 'AA' + } + + self.all_symbols.update(major_adrs) + print(f" βœ… Added {len(major_adrs)} major ADRs") + return list(major_adrs) + + def get_crypto_securities(self): + """Get crypto-related stocks and ETFs""" + print("πŸ“ˆ Fetching crypto-related securities...") + + crypto_securities = { + # Crypto ETFs (2025) + 'IBIT', 'ETHA', 'BITO', 'BLOK', 'ARKK', 'ARKQ', 'ARKW', 'ARKG', 'ARKF', + + # Direct Crypto Stocks + 'COIN', 'MSTR', 'RIOT', 'MARA', 'CLSK', 'HUT', 'BTBT', 'CAN', + 'EBANG', 'SOS', 'BITF', 'ARBK', 'WULF', 'CIFR', 'CORZ', 'HIVE', + 'DMGI', 'BTCS', 'GREE', 'ANY', 'EBON', 'BTC', 'FTFT', 'APLD', + + # Blockchain/Fintech with crypto exposure + 'SQ', 'PYPL', 'HOOD', 'SOFI', 'AFRM', 'UPST', 'LC', 'NU', 'OPEN', + 'COIN', 'RBLX', 'U', 'PATH', 'DKNG', 'PLTR', 'SNOW' + } + + new_symbols = crypto_securities - self.all_symbols + self.all_symbols.update(crypto_securities) + print(f" βœ… Added {len(new_symbols)} new crypto-related securities") + return list(new_symbols) + + def get_market_indices(self): + """Get major market indices""" + print("πŸ“ˆ Fetching market indices...") + + indices = { + # US Indices + '^GSPC', '^DJI', '^IXIC', '^NDX', '^RUT', '^VIX', '^TNX', + '^GSPCTR', '^RUA', '^RUI', '^RUO', '^RUTTR', '^SP600', '^SP400', + '^XAX', '^NYA', '^XMI', '^XOI', '^HGX', '^SOX', '^UTY', '^XAU', + + # International Indices + '^N225', '^HSI', '^FTSE', '^GDAXI', '^FCHI', '^STOXX50E', + '^BVSP', '^MXX', '^KS11', '^TWII', '^AXJO', '^BSESN', '^NSEI', + '^STI', '^KLSE', '^JKSE', '^SET', '^PSEI', '^VNI', '^HNX' + } + + self.all_symbols.update(indices) + print(f" βœ… Added {len(indices)} market indices") + return list(indices) + + def get_additional_popular_stocks(self): + """Add popular stocks that might be missing""" + print("πŸ“ˆ Adding popular stocks...") + + popular_stocks = { + # Meme/Popular stocks + 'GME', 'AMC', 'BBBY', 'NOK', 'BB', 'KOSS', 'EXPR', 'CLOV', 'WISH', + 'SPCE', 'NKLA', 'RIDE', 'LCID', 'RIVN', 'F', 'FORD', + + # Recent IPOs/Popular names + 'RBLX', 'PATH', 'DKNG', 'PENN', 'PLTR', 'U', 'NET', 'FSLY', 'ESTC', + 'ZI', 'DOCU', 'ZM', 'WORK', 'PTON', 'LMND', 'ROOT', 'OPEN', 'COMP', + + # Energy transition + 'ENPH', 'SEDG', 'RUN', 'SPWR', 'FSLR', 'PLUG', 'BE', 'BLDP', 'FUV', + 'HYLN', 'QS', 'BLNK', 'CHPT', 'EVGO', 'WBX', 'ARVL', 'GOEV', + + # Cannabis + 'TLRY', 'CGC', 'ACB', 'CRON', 'HEXO', 'OGI', 'SNDL', 'APHA', + + # SPACs that completed + 'IPOF', 'IPOD', 'IPOE', 'CCIV', 'PSTH', 'THCB', 'SBE', 'QS', + + # International popular + 'GRAB', 'SE', 'CPNG', 'DIDI', 'UBER', 'LYFT', 'DASH', 'SPOT', + + # REITs + 'O', 'VNQ', 'SCHH', 'IYR', 'XLRE', 'REM', 'MORT', 'REZ' + } + + new_symbols = popular_stocks - self.all_symbols + self.all_symbols.update(popular_stocks) + print(f" βœ… Added {len(new_symbols)} new popular stocks") + return list(new_symbols) + + def build_comprehensive_universe(self): + """Build the complete stock universe""" + print("πŸ—οΈ Building comprehensive stock universe for Yahoo Finance...") + print("🎯 Target: 3,000-5,000 unique symbols\n") + + start_time = time.time() + + # Get symbols from all sources + self.get_russell_3000() + self.add_delay() + + self.get_nasdaq_stocks_ftp() + self.add_delay() + + self.get_nyse_stocks_ftp() + self.add_delay() + + self.get_russell_2000() + self.add_delay() + + self.get_major_etfs() + self.get_major_adrs() + self.get_crypto_securities() + self.get_market_indices() + self.get_additional_popular_stocks() + + # Clean and validate symbols + final_symbols = self.clean_and_validate_symbols() + + end_time = time.time() + + # Generate report + self.generate_report(final_symbols, end_time - start_time) + + return final_symbols + + def clean_and_validate_symbols(self): + """Clean and validate the collected symbols""" + print("\n🧹 Cleaning and validating symbols...") + + # Convert to sorted list + raw_symbols = sorted(list(self.all_symbols)) + + # Clean symbols + cleaned_symbols = [] + for symbol in raw_symbols: + if symbol and isinstance(symbol, str): + clean_symbol = symbol.strip().upper() + # Basic validation - allow letters, numbers, -, ., ^ + if (len(clean_symbol) >= 1 and len(clean_symbol) <= 8 and + all(c.isalnum() or c in '^-.' for c in clean_symbol)): + cleaned_symbols.append(clean_symbol) + + print(f" βœ… Cleaned {len(raw_symbols)} -> {len(cleaned_symbols)} valid symbols") + return cleaned_symbols + + def generate_report(self, symbols, duration): + """Generate comprehensive report""" + print(f"\nπŸ“Š COMPREHENSIVE STOCK UNIVERSE REPORT") + print(f"=" * 60) + print(f"🎯 Total unique symbols: {len(symbols)}") + print(f"⏱️ Build time: {duration:.1f} seconds") + print(f"πŸ“… Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") + + # Categorize symbols + stocks = [s for s in symbols if not s.startswith('^') and len(s) <= 5 and '.' not in s] + indices = [s for s in symbols if s.startswith('^')] + etfs_complex = [s for s in symbols if not s.startswith('^') and (len(s) > 4 or '.' in s or '-' in s)] + + print(f"\nπŸ“ˆ BREAKDOWN BY TYPE:") + print(f" Individual Stocks: ~{len(stocks)}") + print(f" Market Indices: {len(indices)}") + print(f" ETFs/Complex: ~{len(symbols) - len(stocks) - len(indices)}") + + # Sample symbols + print(f"\nπŸ“ SAMPLE SYMBOLS:") + print(f" First 20: {symbols[:20]}") + if len(symbols) >= 10: + print(f" Random 10: {random.sample(symbols, min(10, len(symbols)))}") + + # Validation for Yahoo Finance + print(f"\nβœ… YAHOO FINANCE COMPATIBILITY:") + print(f" βœ“ Symbol format validation passed") + print(f" βœ“ Length validation passed (1-8 chars)") + print(f" βœ“ Character validation passed (alphanumeric + ^-.)") + print(f" βœ“ Ready for Yahoo Finance data collection") + + return symbols + + +def main(): + """Main execution function""" + print("πŸš€ COMPREHENSIVE YAHOO FINANCE STOCK UNIVERSE BUILDER") + print("=" * 80) + + builder = StockUniverseBuilder() + + # Build comprehensive universe + symbols = builder.build_comprehensive_universe() + + # Save to file + script_dir = Path(__file__).parent + output_file = script_dir / 'comprehensive_stock_universe.txt' + + with open(output_file, 'w') as f: + for symbol in symbols: + f.write(f"{symbol}\n") + + print(f"\nπŸ’Ύ Universe saved to: {output_file}") + print(f"🎯 Ready for Yahoo Finance data collection with {len(symbols)} symbols!") + print(f"πŸ“ Next step: Use this file with the data collection script") + + return symbols + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/data_collector/yahoo/collect_comprehensive_data.py b/scripts/data_collector/yahoo/collect_comprehensive_data.py new file mode 100644 index 0000000000..11fc69fbbe --- /dev/null +++ b/scripts/data_collector/yahoo/collect_comprehensive_data.py @@ -0,0 +1,337 @@ +#!/usr/bin/env python3 +""" +Comprehensive Yahoo Finance Data Collector for Qlib +Collects data for 8k+ stocks from comprehensive universe +""" + +import os +import sys +import pandas as pd +import numpy as np +from pathlib import Path +import yfinance as yf +from tqdm import tqdm +import time +import warnings +from datetime import datetime, timedelta +import argparse +import json + +# Suppress warnings +warnings.filterwarnings('ignore') + +class ComprehensiveYahooCollector: + """Comprehensive data collector for Yahoo Finance with 8k+ symbols""" + + def __init__(self, universe_file, output_dir, start_date='1990-01-01', end_date='2025-01-01'): + self.universe_file = Path(universe_file) + self.output_dir = Path(output_dir) + self.output_dir.mkdir(parents=True, exist_ok=True) + self.start_date = start_date + self.end_date = end_date + self.delay = 0.05 # Reduced delay for faster collection + + # Load symbols + self.symbols = self.load_symbols() + + # Statistics + self.stats = { + 'total_symbols': len(self.symbols), + 'successful': 0, + 'failed': 0, + 'empty_data': 0, + 'errors': [], + 'start_time': datetime.now() + } + + def load_symbols(self): + """Load symbols from universe file""" + if not self.universe_file.exists(): + raise FileNotFoundError(f"Universe file not found: {self.universe_file}") + + with open(self.universe_file, 'r') as f: + symbols = [line.strip().upper() for line in f.readlines() if line.strip()] + + print(f"πŸ“ˆ Loaded {len(symbols)} symbols from {self.universe_file.name}") + return symbols + + def get_stock_data(self, symbol, retries=3): + """Download data for a single symbol with retries""" + for attempt in range(retries): + try: + # Create ticker object + ticker = yf.Ticker(symbol) + + # Get historical data + data = ticker.history( + start=self.start_date, + end=self.end_date, + auto_adjust=True, # Use adjusted prices + back_adjust=True # Back adjust splits/dividends + ) + + if data.empty: + return None, "No data available" + + # Rename columns to Qlib format + data = data.rename(columns={ + 'Open': '$open', + 'High': '$high', + 'Low': '$low', + 'Close': '$close', # This is already adjusted + 'Volume': '$volume' + }) + + # Calculate additional fields + data['$factor'] = 1.0 # Factor is 1 since we're using adjusted prices + data['$vwap'] = (data['$high'] + data['$low'] + data['$close']) / 3 + + # Reset index to make date a column + data = data.reset_index() + data['date'] = data['Date'] + + # Select required columns + columns_to_keep = ['date', '$open', '$high', '$low', '$close', '$volume', '$vwap', '$factor'] + data = data[[col for col in columns_to_keep if col in data.columns]] + + # Sort by date + data = data.sort_values('date') + + return data, None + + except Exception as e: + error_msg = str(e) + if attempt < retries - 1: + time.sleep(self.delay * (attempt + 1)) # Exponential backoff + continue + else: + return None, error_msg + + return None, "Max retries exceeded" + + def collect_batch(self, symbol_batch, batch_num, total_batches): + """Collect data for a batch of symbols""" + batch_results = { + 'successful': 0, + 'failed': 0, + 'empty_data': 0, + 'errors': [] + } + + print(f"\nπŸ“¦ Processing batch {batch_num}/{total_batches} ({len(symbol_batch)} symbols)") + + for symbol in tqdm(symbol_batch, desc=f"Batch {batch_num}"): + try: + # Clean symbol for filename + clean_symbol = symbol.replace('^', '_').replace('/', '_').replace('.', '_') + output_file = self.output_dir / f"{clean_symbol}.csv" + + # Skip if file already exists + if output_file.exists(): + batch_results['successful'] += 1 + continue + + # Get data + data, error = self.get_stock_data(symbol) + + if error: + batch_results['failed'] += 1 + batch_results['errors'].append(f"{symbol}: {error}") + continue + + if data is None or len(data) == 0: + batch_results['empty_data'] += 1 + continue + + # Save to CSV + data.to_csv(output_file, index=False) + batch_results['successful'] += 1 + + # Add delay to avoid rate limiting + time.sleep(self.delay) + + except Exception as e: + batch_results['failed'] += 1 + batch_results['errors'].append(f"{symbol}: {str(e)}") + continue + + return batch_results + + def collect_all_data(self, batch_size=100, max_symbols=None): + """Collect data for all symbols in batches""" + print("πŸš€ COMPREHENSIVE YAHOO FINANCE DATA COLLECTION") + print("=" * 80) + print(f"πŸ“ˆ Total symbols: {len(self.symbols)}") + print(f"πŸ“… Date range: {self.start_date} to {self.end_date}") + print(f"πŸ’Ύ Output directory: {self.output_dir}") + print(f"πŸ“¦ Batch size: {batch_size}") + + # Limit symbols for testing if specified + symbols_to_process = self.symbols + if max_symbols: + symbols_to_process = self.symbols[:max_symbols] + print(f"πŸ§ͺ Testing mode: limiting to first {max_symbols} symbols") + + # Split into batches + batches = [symbols_to_process[i:i+batch_size] for i in range(0, len(symbols_to_process), batch_size)] + total_batches = len(batches) + + print(f"πŸ“¦ Processing {total_batches} batches...") + + # Process each batch + for i, batch in enumerate(batches, 1): + batch_results = self.collect_batch(batch, i, total_batches) + + # Update global stats + self.stats['successful'] += batch_results['successful'] + self.stats['failed'] += batch_results['failed'] + self.stats['empty_data'] += batch_results['empty_data'] + self.stats['errors'].extend(batch_results['errors']) + + # Print batch summary + print(f" βœ… Successful: {batch_results['successful']}") + print(f" ❌ Failed: {batch_results['failed']}") + print(f" πŸ“­ Empty: {batch_results['empty_data']}") + + # Save progress periodically + if i % 10 == 0 or i == total_batches: + self.save_progress_report() + + # Final summary + self.print_final_summary() + self.save_final_report() + + return self.stats + + def save_progress_report(self): + """Save progress report""" + progress = { + 'timestamp': datetime.now().isoformat(), + 'processed': self.stats['successful'] + self.stats['failed'] + self.stats['empty_data'], + 'total': self.stats['total_symbols'], + 'successful': self.stats['successful'], + 'failed': self.stats['failed'], + 'empty_data': self.stats['empty_data'], + 'success_rate': self.stats['successful'] / max(1, self.stats['successful'] + self.stats['failed']) * 100, + 'recent_errors': self.stats['errors'][-20:] if self.stats['errors'] else [] + } + + progress_file = self.output_dir / 'collection_progress.json' + with open(progress_file, 'w') as f: + json.dump(progress, f, indent=2) + + def print_final_summary(self): + """Print final collection summary""" + self.stats['end_time'] = datetime.now() + duration = self.stats['end_time'] - self.stats['start_time'] + + total_processed = self.stats['successful'] + self.stats['failed'] + self.stats['empty_data'] + success_rate = self.stats['successful'] / max(1, total_processed) * 100 + + print(f"\nπŸŽ‰ COLLECTION COMPLETE!") + print(f"=" * 60) + print(f"⏱️ Duration: {duration}") + print(f"πŸ“Š Total processed: {total_processed}/{self.stats['total_symbols']}") + print(f"βœ… Successful: {self.stats['successful']} ({success_rate:.1f}%)") + print(f"❌ Failed: {self.stats['failed']}") + print(f"πŸ“­ Empty data: {self.stats['empty_data']}") + print(f"πŸ’Ύ Files created: {len(list(self.output_dir.glob('*.csv')))}") + + if self.stats['errors']: + print(f"\n⚠️ Recent errors (last 10):") + for error in self.stats['errors'][-10:]: + print(f" {error}") + + def save_final_report(self): + """Save final collection report""" + report = { + 'collection_summary': { + 'start_time': self.stats['start_time'].isoformat(), + 'end_time': self.stats['end_time'].isoformat(), + 'duration_seconds': (self.stats['end_time'] - self.stats['start_time']).total_seconds(), + 'total_symbols': self.stats['total_symbols'], + 'successful': self.stats['successful'], + 'failed': self.stats['failed'], + 'empty_data': self.stats['empty_data'], + 'success_rate': self.stats['successful'] / max(1, self.stats['successful'] + self.stats['failed']) * 100, + 'files_created': len(list(self.output_dir.glob('*.csv'))) + }, + 'configuration': { + 'universe_file': str(self.universe_file), + 'output_directory': str(self.output_dir), + 'date_range': f"{self.start_date} to {self.end_date}", + 'delay': self.delay + }, + 'all_errors': self.stats['errors'] + } + + report_file = self.output_dir / 'collection_final_report.json' + with open(report_file, 'w') as f: + json.dump(report, f, indent=2) + + # Also save successful symbols list + successful_files = list(self.output_dir.glob('*.csv')) + successful_symbols = [f.stem.replace('_', '^') for f in successful_files if f.stem != 'collection_progress' and f.stem != 'collection_final_report'] + + symbols_file = self.output_dir / 'successful_symbols.txt' + with open(symbols_file, 'w') as f: + for symbol in sorted(successful_symbols): + f.write(f"{symbol}\n") + + print(f"πŸ“ Final report saved to: {report_file}") + print(f"πŸ“ Successful symbols saved to: {symbols_file}") + + +def main(): + """Main execution function""" + parser = argparse.ArgumentParser(description='Comprehensive Yahoo Finance data collection') + parser.add_argument('--universe_file', + default='/workspace/qlib/scripts/data_collector/yahoo/comprehensive_stock_universe.txt', + help='Universe file with symbols to collect') + parser.add_argument('--output_dir', + default='/workspace/qlib/data/comprehensive_yahoo_data', + help='Output directory for data files') + parser.add_argument('--start_date', + default='1990-01-01', + help='Start date (YYYY-MM-DD)') + parser.add_argument('--end_date', + default='2025-01-01', + help='End date (YYYY-MM-DD)') + parser.add_argument('--batch_size', + type=int, + default=100, + help='Batch size for processing') + parser.add_argument('--max_symbols', + type=int, + default=None, + help='Limit number of symbols (for testing)') + parser.add_argument('--test_run', + action='store_true', + help='Run with first 50 symbols for testing') + + args = parser.parse_args() + + # Override for test run + if args.test_run: + args.max_symbols = 50 + print("πŸ§ͺ TEST RUN MODE: Processing first 50 symbols") + + # Create collector + collector = ComprehensiveYahooCollector( + universe_file=args.universe_file, + output_dir=args.output_dir, + start_date=args.start_date, + end_date=args.end_date + ) + + # Start collection + stats = collector.collect_all_data( + batch_size=args.batch_size, + max_symbols=args.max_symbols + ) + + return stats + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/data_collector/yahoo/comprehensive_stock_universe.txt b/scripts/data_collector/yahoo/comprehensive_stock_universe.txt new file mode 100644 index 0000000000..7579df137a --- /dev/null +++ b/scripts/data_collector/yahoo/comprehensive_stock_universe.txt @@ -0,0 +1,8060 @@ +A +AA +AACB +AACBR +AACBU +AACG +AACI +AACIU +AACIW +AACT +AADR +AAL +AALG +AAM +AAME +AAMI +AAOI +AAON +AAP +AAPB +AAPD +AAPG +AAPL +AAPU +AARD +AAT +AAUC +AAUS +AAVM +AAXJ +AB +ABAT +ABBV +ABCB +ABCL +ABCS +ABEO +ABEV +ABG +ABI +ABIG +ABL +ABLLL +ABLV +ABLVW +ABM +ABNB +ABOS +ABP +ABPWW +ABR +ABR-D +ABR-E +ABR-F +ABSI +ABT +ABTC +ABTS +ABUS +ABVC +ABVE +ABVEW +ABVX +ABX +ACA +ACAD +ACB +ACCO +ACDC +ACEL +ACET +ACFN +ACGL +ACGLN +ACGLO +ACHC +ACHR +ACHV +ACI +ACIC +ACIU +ACIW +ACLO +ACLS +ACLX +ACM +ACMR +ACN +ACNB +ACNT +ACOG +ACON +ACONW +ACP +ACP-A +ACR +ACR-C +ACR-D +ACRE +ACRS +ACRV +ACT +ACTG +ACTU +ACV +ACVA +ACWI +ACWX +ACXP +AD +ADAG +ADAM +ADAMG +ADAMH +ADAMI +ADAML +ADAMM +ADAMN +ADAMZ +ADAP +ADBE +ADBG +ADC +ADC-A +ADCT +ADEA +ADGM +ADI +ADIL +ADM +ADMA +ADN +ADNT +ADNWW +ADP +ADPT +ADSE +ADSEW +ADSK +ADT +ADTN +ADTX +ADUR +ADUS +ADV +ADVB +ADVM +ADVWW +ADX +ADXN +AEBI +AEE +AEFC +AEG +AEHL +AEHR +AEI +AEIS +AEM +AEMD +AENT +AENTW +AEO +AEP +AER +AERT +AERTW +AES +AESI +AEVA +AEVAW +AEYE +AFB +AFBI +AFCG +AFG +AFGB +AFGC +AFGD +AFGE +AFJK +AFJKR +AFJKU +AFL +AFOS +AFRI +AFRIW +AFRM +AFSC +AFYA +AG +AGAE +AGCO +AGD +AGEM +AGEN +AGG +AGGA +AGH +AGI +AGIO +AGIX +AGL +AGM +AGM-D +AGM-E +AGM-F +AGM-G +AGM-H +AGM.A +AGMH +AGMI +AGNC +AGNCL +AGNCM +AGNCN +AGNCO +AGNCP +AGNG +AGO +AGRI +AGRO +AGX +AGYS +AGZD +AHCO +AHG +AHH +AHH-A +AHL +AHL-D +AHL-E +AHL-F +AHR +AHT +AHT-D +AHT-F +AHT-G +AHT-H +AHT-I +AI +AIA +AIFD +AIFF +AIFU +AIG +AIHS +AII +AIIO +AIIOW +AIMD +AIMDW +AIN +AIO +AIOT +AIP +AIPI +AIPO +AIQ +AIR +AIRE +AIRG +AIRJ +AIRJW +AIRL +AIRO +AIRR +AIRS +AIRT +AIRTP +AISP +AISPW +AIT +AIV +AIXI +AIZ +AIZN +AJG +AKA +AKAF +AKAM +AKAN +AKBA +AKO.A +AKO.B +AKR +AKRO +AKTX +AL +ALAB +ALAR +ALB +ALB-A +ALBT +ALC +ALCO +ALCY +ALCYU +ALCYW +ALDF +ALDFU +ALDFW +ALDX +ALE +ALEC +ALEX +ALF +ALFUU +ALFUW +ALG +ALGM +ALGN +ALGS +ALGT +ALHC +ALIL +ALIT +ALK +ALKS +ALKT +ALL +ALL-B +ALL-H +ALL-I +ALL-J +ALLE +ALLO +ALLR +ALLT +ALLW +ALLY +ALM +ALMS +ALMU +ALNT +ALNY +ALOT +ALRM +ALRS +ALSN +ALT +ALTG +ALTI +ALTO +ALTS +ALTY +ALUR +ALV +ALVO +ALVOW +ALX +ALXO +ALZN +AM +AMAL +AMAT +AMBA +AMBC +AMBP +AMBQ +AMBR +AMC +AMCR +AMCX +AMD +AMDD +AMDG +AMDL +AMDU +AME +AMG +AMGN +AMH +AMH-G +AMH-H +AMID +AMIX +AMKR +AMLX +AMN +AMOD +AMODW +AMP +AMPG +AMPGW +AMPH +AMPL +AMPX +AMPY +AMR +AMRC +AMRK +AMRN +AMRX +AMRZ +AMSC +AMSF +AMST +AMT +AMTB +AMTD +AMTM +AMTX +AMUU +AMWD +AMWL +AMX +AMZD +AMZN +AMZU +AMZZ +AN +ANAB +ANDE +ANEB +ANEL +ANET +ANF +ANG-B +ANG-D +ANGH +ANGHW +ANGI +ANGL +ANGO +ANIK +ANIP +ANIX +ANL +ANNA +ANNAW +ANNX +ANPA +ANRO +ANSC +ANSCU +ANSCW +ANTA +ANTE +ANTX +ANVS +ANY +AOD +AOHY +AOMD +AOMN +AOMR +AON +AORT +AOS +AOSL +AOTG +AOUT +AP +APA +APAD +APADR +APADU +APAM +APD +APDN +APED +APEI +APG +APGE +APH +APHA +API +APLD +APLE +APLM +APLMW +APLS +APLT +APM +APO +APO-A +APOG +APOS +APP +APPF +APPN +APPS +APPX +APRE +APTV +APVO +APWC +APYX +AQB +AQMS +AQN +AQNB +AQST +AQWA +AR +ARAI +ARAY +ARBB +ARBE +ARBEW +ARBK +ARBKL +ARCB +ARCC +ARCO +ARCT +ARDC +ARDT +ARDX +ARE +AREB +AREBW +AREC +ARES +ARGD +ARGX +ARHS +ARI +ARIS +ARKF +ARKG +ARKK +ARKO +ARKOW +ARKQ +ARKR +ARKW +ARL +ARLO +ARLP +ARM +ARMG +ARMK +AROC +AROW +ARQ +ARQQ +ARQQW +ARQT +ARR +ARR-C +ARRY +ARTL +ARTNA +ARTV +ARTW +ARVL +ARVN +ARVR +ARW +ARWR +ARX +AS +ASA +ASAN +ASB +ASB-E +ASB-F +ASBA +ASBP +ASBPW +ASC +ASET +ASG +ASGI +ASGN +ASH +ASHR +ASIC +ASIX +ASLE +ASMB +ASMG +ASML +ASND +ASNS +ASO +ASPC +ASPCR +ASPCU +ASPI +ASPN +ASPS +ASPSW +ASPSZ +ASR +ASRT +ASRV +ASST +ASTC +ASTE +ASTH +ASTI +ASTL +ASTLW +ASTS +ASUR +ASX +ASYS +ATAI +ATAT +ATEC +ATEN +ATER +ATEX +ATGE +ATGL +ATH-A +ATH-B +ATH-D +ATH-E +ATHA +ATHE +ATHM +ATHR +ATHS +ATI +ATII +ATIIU +ATIIW +ATKR +ATLC +ATLCL +ATLCP +ATLCZ +ATLN +ATLO +ATLX +ATMC +ATMCR +ATMCU +ATMCW +ATMU +ATMV +ATMVR +ATMVU +ATNI +ATO +ATOM +ATON +ATOS +ATPC +ATR +ATRA +ATRC +ATRO +ATS +ATUS +ATXG +ATXS +ATYR +AU +AUB +AUB-A +AUBN +AUDC +AUGO +AUID +AUMI +AUNA +AUPH +AUR +AURA +AUROW +AUTL +AUUD +AUUDW +AVA +AVAH +AVAL +AVAV +AVB +AVBC +AVBH +AVBP +AVD +AVDL +AVDX +AVGB +AVGG +AVGO +AVGU +AVGX +AVIR +AVK +AVL +AVNS +AVNT +AVNW +AVO +AVPT +AVR +AVS +AVT +AVTR +AVTX +AVUQ +AVXC +AVXL +AVY +AWF +AWI +AWK +AWP +AWR +AWRE +AX +AXGN +AXIN +AXINR +AXINU +AXL +AXON +AXP +AXR +AXS +AXS-E +AXSM +AXTA +AXTI +AYI +AYTU +AZ +AZI +AZN +AZO +AZRE +AZTA +AZZ +B +BA +BA-A +BABA +BABX +BAC +BAC-B +BAC-E +BAC-K +BAC-L +BAC-M +BAC-N +BAC-O +BAC-P +BAC-Q +BAC-S +BACC +BACCR +BACCU +BACQ +BACQR +BACQU +BAER +BAERW +BAFE +BAFN +BAH +BAIG +BAK +BAL +BALL +BALY +BAM +BANC +BAND +BANF +BANFP +BANL +BANR +BANX +BAOS +BAP +BARK +BASE +BASG +BASV +BATRA +BATRK +BAX +BAYA +BAYAR +BAYAU +BB +BBAI +BBAR +BBB +BBBY +BBCP +BBD +BBDC +BBDO +BBGI +BBH +BBIO +BBLG +BBLGW +BBN +BBNX +BBOT +BBSI +BBT +BBU +BBUC +BBVA +BBW +BBWI +BBY +BC +BC-A +BC-C +BCAB +BCAL +BCAR +BCARU +BCARW +BCAT +BCAX +BCBP +BCC +BCDA +BCE +BCG +BCGWW +BCH +BCIC +BCLO +BCML +BCO +BCPC +BCRX +BCS +BCSF +BCTX +BCTXW +BCTXZ +BCX +BCYC +BDC +BDGS +BDJ +BDMD +BDMDW +BDN +BDRX +BDSX +BDTX +BDX +BE +BEAG +BEAGR +BEAGU +BEAM +BEAT +BEATW +BEDU +BEEM +BEEP +BEEX +BEEZ +BEKE +BELFA +BELFB +BELT +BEN +BENF +BENFW +BEP +BEP-A +BEPC +BEPH +BEPI +BEPJ +BETR +BETRW +BF.A +BF.B +BFAM +BFC +BFH +BFIN +BFK +BFLY +BFRG +BFRGW +BFRI +BFRIW +BFS +BFS-D +BFS-E +BFST +BFZ +BG +BGB +BGC +BGFV +BGH +BGL +BGLC +BGLWW +BGM +BGR +BGRN +BGRO +BGS +BGSF +BGT +BGX +BGY +BH +BH.A +BHAT +BHC +BHE +BHF +BHFAL +BHFAM +BHFAN +BHFAO +BHFAP +BHK +BHP +BHR +BHR-B +BHR-D +BHRB +BHST +BHV +BHVN +BIAF +BIAFW +BIB +BIDU +BIIB +BILI +BILL +BINI +BIO +BIO.B +BIOA +BIOX +BIP +BIP-A +BIP-B +BIPC +BIPH +BIPI +BIPJ +BIRD +BIRK +BIS +BIT +BITF +BITO +BITS +BIVI +BIVIW +BIYA +BJ +BJDX +BJK +BJRI +BK +BK-K +BKCH +BKD +BKE +BKH +BKHA +BKHAR +BKHAU +BKIV +BKKT +BKN +BKNG +BKR +BKSY +BKT +BKU +BKV +BKWO +BKYI +BL +BLBD +BLBX +BLCN +BLCO +BLCR +BLD +BLDP +BLDR +BLE +BLFS +BLFY +BLIN +BLIV +BLK +BLKB +BLMN +BLMZ +BLND +BLNE +BLNK +BLOK +BLRX +BLSH +BLTE +BLUW +BLUWU +BLUWW +BLW +BLX +BLZE +BMA +BMAX +BMBL +BMDL +BME +BMEA +BMEZ +BMGL +BMHL +BMI +BML-G +BML-H +BML-J +BML-L +BMN +BMO +BMR +BMRA +BMRC +BMRN +BMY +BN +BNAI +BNAIW +BNC +BNCWW +BND +BNDW +BNDX +BNED +BNGO +BNH +BNJ +BNL +BNR +BNRG +BNS +BNT +BNTC +BNTX +BNY +BNZI +BNZIW +BOC +BODI +BOE +BOED +BOEG +BOEU +BOF +BOH +BOH-A +BOH-B +BOKF +BOLD +BOLT +BON +BOND +BOOM +BOOT +BORR +BOSC +BOTJ +BOTT +BOTZ +BOW +BOWN +BOWNR +BOWNU +BOX +BOXL +BP +BPOP +BPOPM +BPRN +BPYPM +BPYPN +BPYPO +BPYPP +BR +BRAG +BRBR +BRC +BRCC +BREA +BRFH +BRFS +BRHY +BRID +BRK-A +BRK-B +BRK.A +BRK.B +BRKD +BRKR +BRKU +BRLS +BRLSW +BRLT +BRNS +BRNY +BRO +BROS +BRR +BRRR +BRRWU +BRRWW +BRSL +BRSP +BRT +BRTR +BRTX +BRW +BRX +BRY +BRZE +BSAA +BSAAR +BSAAU +BSAC +BSBK +BSBR +BSCP +BSCQ +BSCR +BSCS +BSCT +BSCU +BSCV +BSCW +BSCX +BSCY +BSCZ +BSET +BSGM +BSJP +BSJQ +BSJR +BSJS +BSJT +BSJU +BSJV +BSJW +BSJX +BSL +BSLK +BSLKW +BSM +BSMP +BSMQ +BSMR +BSMS +BSMT +BSMU +BSMV +BSMW +BSMY +BSRR +BSSX +BST +BSTZ +BSVN +BSVO +BSX +BSY +BTA +BTAI +BTBD +BTBDW +BTBT +BTC +BTCM +BTCS +BTCT +BTDR +BTE +BTF +BTFX +BTGD +BTI +BTM +BTMD +BTMWW +BTO +BTOC +BTOG +BTSG +BTSGU +BTT +BTU +BTX +BTZ +BUD +BUFC +BUFI +BUFM +BUG +BUI +BULD +BULG +BULL +BULLW +BULX +BUR +BURL +BUSE +BUSEP +BUUU +BUXX +BV +BVFL +BVN +BVS +BW +BW-A +BWA +BWAY +BWB +BWBBP +BWEN +BWFG +BWG +BWIN +BWLP +BWMN +BWMX +BWNB +BWSN +BWXT +BX +BXC +BXMT +BXMX +BXP +BXSL +BY +BYD +BYFC +BYM +BYND +BYRN +BYSI +BZ +BZAI +BZAIW +BZFD +BZFDW +BZH +BZUN +C +C-N +CA +CAAP +CAAS +CABA +CABO +CAC +CACC +CACI +CADE +CADL +CAE +CAEP +CAF +CAFE +CAFG +CAG +CAH +CAI +CAKE +CAL +CALC +CALI +CALM +CALX +CAMP +CAMT +CAN +CANC +CANE +CANG +CANQ +CAPL +CAPN +CAPNR +CAPNU +CAPR +CAPS +CAPT +CAPTW +CAR +CARE +CARG +CARL +CARM +CARR +CARS +CART +CARV +CARY +CARZ +CASH +CASI +CASK +CASS +CASY +CAT +CATH +CATO +CATY +CAVA +CB +CBAN +CBAT +CBFV +CBIO +CBL +CBLL +CBNA +CBNK +CBO +CBRE +CBRL +CBSH +CBT +CBU +CBUS +CBX +CBZ +CC +CCAP +CCB +CCBG +CCCC +CCCS +CCCX +CCCXU +CCCXW +CCD +CCEC +CCEP +CCFE +CCG +CCGWW +CCI +CCIA +CCIF +CCII +CCIIU +CCIIW +CCIV +CCIX +CCIXU +CCIXW +CCJ +CCK +CCL +CCLD +CCLDO +CCM +CCNE +CCNEP +CCNR +CCO +CCOI +CCRD +CCRN +CCS +CCSB +CCSI +CCSO +CCTG +CCU +CCZ +CDC +CDE +CDIO +CDIOW +CDL +CDLR +CDLX +CDNA +CDNS +CDP +CDR-B +CDR-C +CDRE +CDRO +CDROW +CDT +CDTG +CDTTW +CDTX +CDW +CDXS +CDZI +CDZIP +CE +CECO +CEE +CEFA +CEG +CELC +CELH +CELU +CELUW +CELZ +CENN +CENT +CENTA +CENX +CEP +CEPF +CEPI +CEPO +CEPT +CEPU +CERO +CEROW +CERS +CERT +CETX +CETY +CEVA +CF +CFA +CFBK +CFFI +CFFN +CFG +CFG-E +CFG-H +CFG-I +CFLT +CFND +CFO +CFR +CFR-B +CFSB +CG +CGABL +CGAU +CGBD +CGBDL +CGC +CGCT +CGCTU +CGCTW +CGEM +CGEN +CGNT +CGNX +CGO +CGON +CGTL +CGTX +CGV +CHA +CHAC +CHACR +CHACU +CHAR +CHARR +CHARU +CHCI +CHCO +CHCT +CHD +CHDN +CHE +CHEF +CHEK +CHGG +CHGX +CHH +CHI +CHKP +CHL +CHMG +CHMI +CHN +CHNR +CHPG +CHPGR +CHPGU +CHPS +CHPT +CHR +CHRD +CHRS +CHRW +CHSCL +CHSCM +CHSCN +CHSCO +CHSCP +CHSN +CHT +CHTR +CHW +CHWY +CHY +CHYM +CI +CIA +CIB +CIBR +CICB +CIEN +CIF +CIFR +CIFRW +CIG +CIG.C +CIGI +CIGL +CII +CIIT +CIL +CIM +CIM-A +CIM-B +CIM-C +CIM-D +CIMN +CIMO +CINF +CING +CINGW +CINT +CIO +CIO-A +CION +CISO +CISS +CIVB +CIVI +CJET +CJMB +CL +CLAR +CLB +CLBK +CLBT +CLCO +CLDT +CLDX +CLF +CLFD +CLGN +CLH +CLIK +CLIR +CLLS +CLMB +CLMT +CLNE +CLNN +CLNNW +CLOA +CLOD +CLOU +CLOV +CLPR +CLPS +CLPT +CLRB +CLRO +CLS +CLSD +CLSK +CLSKW +CLSM +CLST +CLVT +CLW +CLWT +CLX +CLYM +CM +CMA +CMA-B +CMBM +CMBT +CMC +CMCM +CMCO +CMCSA +CMCT +CMDB +CME +CMG +CMI +CMMB +CMND +CMP +CMPO +CMPOW +CMPR +CMPS +CMPX +CMRC +CMRE +CMS +CMS-B +CMS-C +CMSA +CMSC +CMSD +CMTG +CMTL +CMU +CNA +CNC +CNCK +CNCKW +CNDT +CNET +CNEY +CNF +CNFR +CNFRZ +CNH +CNI +CNK +CNM +CNMD +CNNE +CNO +CNO-A +CNOB +CNOBP +CNP +CNQ +CNR +CNS +CNSP +CNTA +CNTB +CNTX +CNTY +CNVS +CNX +CNXC +CNXN +COCH +COCHW +COCO +COCP +CODA +CODI +CODX +COEP +COEPW +COF +COF-I +COF-J +COF-K +COF-L +COF-N +COFS +COGT +COHR +COHU +COIG +COIN +COKE +COLA +COLAR +COLAU +COLB +COLD +COLL +COLM +COMM +COMP +COMT +CON +CONI +CONL +COO +COOK +COOP +COOT +COOTW +COP +COPJ +COPL +COPP +COR +CORN +CORO +CORT +CORZ +CORZW +CORZZ +COSM +COSO +COST +COTY +COUR +COWG +COWS +COYA +COYY +CP +CPA +CPAC +CPAG +CPAI +CPAY +CPB +CPBI +CPF +CPHC +CPHY +CPIX +CPK +CPLS +CPNG +CPOP +CPRI +CPRT +CPRX +CPS +CPSH +CPSS +CPT +CPZ +CQP +CR +CRAI +CRAQ +CRAQR +CRAQU +CRBD +CRBG +CRBP +CRBU +CRC +CRCG +CRCL +CRCT +CRD.A +CRD.B +CRDF +CRDL +CRDO +CRE +CREG +CRESW +CRESY +CREV +CREVW +CREX +CRGO +CRGOW +CRGY +CRH +CRI +CRIS +CRK +CRL +CRM +CRMD +CRMG +CRML +CRMLW +CRMT +CRNC +CRNT +CRNX +CRON +CROX +CRS +CRSP +CRSR +CRT +CRTO +CRUS +CRVL +CRVO +CRVS +CRWD +CRWG +CRWL +CRWS +CRWV +CSAI +CSAN +CSB +CSBR +CSCL +CSCO +CSCS +CSGP +CSGS +CSIQ +CSL +CSPI +CSQ +CSR +CSTE +CSTL +CSTM +CSV +CSW +CSWC +CSWCZ +CSX +CTA-A +CTA-B +CTAS +CTBB +CTBI +CTDD +CTEC +CTEST +CTEV +CTKB +CTLP +CTMX +CTNM +CTNT +CTO +CTO-A +CTOR +CTOS +CTRA +CTRE +CTRI +CTRM +CTRN +CTS +CTSH +CTSO +CTVA +CTW +CTXR +CUB +CUBB +CUBE +CUBI +CUBWU +CUBWW +CUE +CUK +CULP +CUPR +CURB +CURE +CURI +CURIW +CURR +CURV +CURX +CUZ +CV +CVAC +CVBF +CVCO +CVE +CVEO +CVGI +CVGW +CVI +CVKD +CVLG +CVLT +CVNA +CVNX +CVRX +CVS +CVV +CVX +CW +CWAN +CWBC +CWCO +CWD +CWEN +CWH +CWK +CWST +CWT +CX +CXAI +CXAIW +CXDO +CXE +CXH +CXM +CXSE +CXT +CXW +CYBR +CYCC +CYCCP +CYCN +CYCU +CYCUW +CYD +CYH +CYN +CYRX +CYTK +CZAR +CZFS +CZNC +CZR +CZWI +D +DAAQ +DAAQU +DAAQW +DAC +DADS +DAIC +DAICW +DAIO +DAK +DAKT +DAL +DALI +DALN +DAN +DAO +DAPP +DAR +DARE +DASH +DAVA +DAVE +DAVEW +DAWN +DAX +DAY +DB +DBA +DBD +DBGI +DBI +DBL +DBRG +DBVT +DBX +DCBO +DCGO +DCI +DCO +DCOM +DCOMG +DCOMP +DCTH +DD +DDD +DDI +DDIV +DDL +DDOG +DDS +DDT +DE +DEA +DEC +DECK +DECO +DEFT +DEI +DELL +DEMZ +DENN +DEO +DERM +DEVS +DFDV +DFGP +DFGX +DFH +DFIN +DFLI +DFLIW +DFP +DFSC +DFSCW +DG +DGCB +DGICA +DGICB +DGII +DGLO +DGLY +DGNX +DGRE +DGRO +DGRS +DGRW +DGX +DGXX +DH +DHAI +DHAIW +DHC +DHCNI +DHCNL +DHF +DHI +DHIL +DHR +DHT +DHX +DIAX +DIBS +DIDI +DIN +DINO +DIOD +DIS +DIVD +DIVY +DJCO +DJP +DJT +DJTWW +DK +DKI +DKL +DKNG +DKNX +DKS +DLB +DLHC +DLLL +DLNG +DLO +DLPN +DLR +DLR-J +DLR-K +DLR-L +DLTH +DLTR +DLX +DLXY +DLY +DMA +DMAA +DMAAR +DMAAU +DMAC +DMAT +DMB +DMGI +DMLP +DMO +DMRC +DMXF +DNA +DNLI +DNOW +DNP +DNTH +DNUT +DOC +DOCN +DOCS +DOCU +DOGZ +DOLE +DOMH +DOMO +DOOO +DORM +DOUG +DOV +DOW +DOX +DOYU +DPG +DPRO +DPZ +DQ +DRCT +DRD +DRDB +DRDBU +DRDBW +DRH +DRH-A +DRI +DRIO +DRIV +DRLL +DRMA +DRMAW +DRRX +DRS +DRTS +DRTSW +DRUG +DRVN +DSGN +DSGR +DSGX +DSL +DSM +DSMC +DSP +DSTX +DSU +DSWL +DSX +DSX-B +DSY +DSYWW +DT +DTB +DTCK +DTCR +DTE +DTF +DTG +DTI +DTIL +DTM +DTSQ +DTSQR +DTSQU +DTSS +DTST +DTSTW +DTW +DUK +DUK-A +DUKB +DUKH +DUKX +DUO +DUOL +DUOT +DV +DVA +DVAL +DVAX +DVIN +DVLT +DVLU +DVN +DVOL +DVQQ +DVRE +DVSP +DVUT +DVXB +DVXC +DVXE +DVXF +DVXK +DVXP +DVXV +DVXY +DVY +DWAS +DWAW +DWSH +DWSN +DWTX +DWUS +DX +DX-C +DXC +DXCM +DXLG +DXPE +DXR +DXST +DXYZ +DY +DYAI +DYCQ +DYCQR +DYCQU +DYFI +DYN +DYTA +E +EA +EAF +EAI +EARN +EAT +EB +EBANG +EBAY +EBC +EBF +EBI +EBIZ +EBMT +EBON +EBR +EBR.B +EBS +EC +ECAT +ECBK +ECC +ECC-D +ECCC +ECCF +ECCU +ECCV +ECCW +ECCX +ECDA +ECDAW +ECG +ECH +ECL +ECO +ECOR +ECOW +ECPG +ECVT +ECX +ECXWW +ED +EDAP +EDBL +EDBLW +EDD +EDF +EDHL +EDIT +EDN +EDRY +EDSA +EDTK +EDU +EDUC +EE +EEA +EEFT +EEIQ +EEM +EEMA +EEX +EFA +EFAS +EFC +EFC-A +EFC-B +EFC-C +EFC-D +EFOI +EFR +EFRA +EFSC +EFSCP +EFSI +EFT +EFTY +EFX +EFXT +EG +EGAN +EGBN +EGGQ +EGHA +EGHAR +EGHAU +EGHT +EGO +EGP +EGY +EH +EHAB +EHC +EHGO +EHI +EHLD +EHLS +EHTH +EIC +EICA +EICB +EICC +EIG +EIIA +EIX +EJH +EKG +EKSO +EL +ELAB +ELAN +ELBM +ELC +ELDN +ELF +ELFY +ELIL +ELIS +ELME +ELOG +ELP +ELPC +ELPW +ELS +ELSE +ELTK +ELTX +ELUT +ELV +ELVA +ELVN +ELVR +ELWS +EM +EMA +EMB +EMBC +EMCB +EMD +EME +EMEQ +EMF +EMIF +EML +EMN +EMO +EMP +EMPD +EMPG +EMR +EMXC +EMXF +ENB +ENDW +ENFY +ENGN +ENGNW +ENGS +ENIC +ENJ +ENLT +ENLV +ENO +ENOV +ENPH +ENR +ENS +ENSC +ENSG +ENTA +ENTG +ENTO +ENTX +ENVA +ENVB +ENVX +ENZL +EOD +EOG +EOI +EOLS +EOS +EOSE +EOSEW +EOT +EP-C +EPAC +EPAM +EPC +EPD +EPIX +EPOW +EPP +EPR +EPR-C +EPR-E +EPR-G +EPRT +EPRX +EPSM +EPSN +EPU +EPWK +EQ +EQBK +EQH +EQH-A +EQH-C +EQIX +EQNR +EQR +EQRR +EQS +EQT +EQV +ERAS +ERET +ERIC +ERIE +ERII +ERJ +ERNA +ERNZ +ERO +ES +ESAB +ESCA +ESE +ESEA +ESGD +ESGE +ESGL +ESGLW +ESGU +ESHA +ESHAR +ESI +ESLA +ESLAW +ESLT +ESMV +ESN +ESNT +ESOA +ESPO +ESPR +ESQ +ESRT +ESS +ESTA +ESTC +ET +ET-I +ETB +ETD +ETEC +ETG +ETHA +ETHM +ETHMU +ETHMW +ETHZ +ETHZW +ETI- +ETJ +ETN +ETNB +ETO +ETON +ETOR +ETR +ETRL +ETS +ETSY +ETV +ETW +ETX +ETY +EU +EUDA +EUDAW +EUFN +EURK +EURKR +EURKU +EVAC +EVAX +EVC +EVCM +EVER +EVEX +EVF +EVG +EVGN +EVGO +EVGOW +EVH +EVLV +EVLVW +EVMT +EVN +EVO +EVOK +EVR +EVRG +EVSD +EVT +EVTC +EVTL +EVTR +EVTV +EVYM +EW +EWA +EWBC +EWC +EWCZ +EWD +EWG +EWH +EWI +EWJ +EWJV +EWK +EWL +EWM +EWO +EWP +EWQ +EWS +EWT +EWTX +EWU +EWW +EWY +EWZ +EWZS +EXAS +EXC +EXE +EXEEL +EXEEW +EXEEZ +EXEL +EXFY +EXG +EXK +EXLS +EXOZ +EXP +EXPD +EXPE +EXPI +EXPO +EXPR +EXR +EXTR +EXUS +EYE +EYEG +EYPT +EZA +EZGO +EZPW +F +F-B +F-C +F-D +FA +FAAR +FAAS +FAASW +FAB +FACT +FACTU +FACTW +FAD +FAF +FALN +FAMI +FANG +FARM +FAST +FAT +FATBB +FATBP +FATE +FATN +FBGL +FBIN +FBIO +FBIOP +FBIZ +FBK +FBL +FBLA +FBLG +FBNC +FBOT +FBP +FBRT +FBRX +FBYD +FBYDW +FC +FCA +FCAL +FCAP +FCBC +FCCO +FCEF +FCEL +FCF +FCFS +FCHL +FCN +FCNCA +FCNCO +FCNCP +FCPT +FCRX +FCT +FCTE +FCUV +FCVT +FCX +FDBC +FDCF +FDFF +FDIF +FDIG +FDIV +FDMT +FDNI +FDP +FDS +FDSB +FDT +FDTS +FDTX +FDUS +FDVV +FDX +FE +FEAM +FEAT +FEBO +FEDU +FEGE +FEIM +FELE +FEM +FEMB +FEMS +FEMY +FENC +FENG +FEOE +FEP +FEPI +FER +FERA +FERAR +FERAU +FERG +FET +FEUZ +FEX +FF +FFA +FFAI +FFAIW +FFBC +FFC +FFIC +FFIN +FFIV +FFUT +FFWM +FG +FGBI +FGBIP +FGEN +FGI +FGIWW +FGL +FGM +FGMC +FGMCR +FGMCU +FGN +FGNX +FGNXP +FGSI +FGSN +FHB +FHI +FHN +FHN-C +FHN-E +FHN-F +FHTX +FI +FIBK +FICO +FICS +FID +FIEE +FIG +FIGS +FIGX +FIGXU +FIGXW +FIHL +FINE +FINS +FINV +FINW +FINX +FIP +FIS +FISI +FISV +FITB +FITBI +FITBO +FITBP +FIVE +FIVN +FIVY +FIX +FIXD +FIXT +FIZZ +FJP +FKU +FKWL +FL +FLC +FLD +FLDB +FLDDW +FLEX +FLG +FLG-A +FLG-U +FLGC +FLGT +FLL +FLN +FLNC +FLNG +FLNT +FLO +FLOC +FLOT +FLR +FLS +FLUT +FLUX +FLWS +FLX +FLXR +FLXS +FLY +FLYE +FLYW +FMAO +FMB +FMBH +FMC +FMED +FMET +FMFC +FMHI +FMN +FMNB +FMS +FMST +FMSTW +FMTM +FMUB +FMUN +FMX +FMY +FN +FNB +FND +FNF +FNGR +FNK +FNKO +FNLC +FNV +FNWB +FNWD +FNX +FNY +FOA +FOF +FOLD +FONR +FOR +FORA +FORD +FORL +FORLU +FORLW +FORM +FORR +FORTY +FOSL +FOSLL +FOUR +FOX +FOXA +FOXF +FOXX +FOXXW +FPA +FPAY +FPF +FPH +FPI +FPXE +FPXI +FR +FRA +FRAF +FRBA +FRD +FRDD +FRDU +FRGE +FRGT +FRHC +FRME +FRMEP +FRO +FROG +FRPH +FRPT +FRSH +FRST +FRSX +FRT +FRT-C +FSBC +FSBW +FSCO +FSCS +FSEA +FSFG +FSGS +FSHP +FSHPR +FSHPU +FSK +FSLR +FSLY +FSM +FSS +FSTR +FSUN +FSV +FSZ +FT +FTA +FTAG +FTAI +FTAIM +FTAIN +FTC +FTCI +FTCS +FTDR +FTDS +FTEK +FTEL +FTFT +FTGC +FTGS +FTHI +FTHM +FTHY +FTI +FTK +FTLF +FTNT +FTQI +FTRE +FTRI +FTRK +FTS +FTSL +FTSM +FTV +FTWO +FTXG +FTXH +FTXL +FTXN +FTXO +FTXR +FUBO +FUFU +FUFUW +FUJHY +FUL +FULC +FULT +FULTP +FUN +FUNC +FUND +FUSB +FUTU +FUV +FV +FVC +FVCB +FVN +FVNNR +FVNNU +FVR +FVRR +FWONA +FWONK +FWRD +FWRG +FXED +FXI +FXNC +FYBR +FYC +FYT +FYX +G +GAB +GAB-G +GAB-H +GAB-K +GABC +GAIA +GAIN +GAINI +GAINL +GAINN +GAINZ +GALT +GAM +GAM-B +GAMB +GAME +GANX +GAP +GASS +GATX +GAUZ +GBAB +GBCI +GBDC +GBFH +GBIO +GBLI +GBTG +GBUG +GBX +GCBC +GCI +GCL +GCLWW +GCMG +GCMGW +GCO +GCT +GCTK +GCTS +GCV +GD +GDC +GDDY +GDEN +GDEV +GDEVW +GDHG +GDIV +GDL +GDO +GDOT +GDRX +GDS +GDTC +GDV +GDV-H +GDV-K +GDX +GDXJ +GDYN +GE +GECC +GECCH +GECCI +GECCO +GECCZ +GEF +GEF.B +GEG +GEGGL +GEHC +GEL +GELS +GEME +GEN +GENI +GENK +GENVR +GEO +GEOS +GERN +GES +GETY +GEV +GEVO +GF +GFAI +GFAIW +GFF +GFGF +GFI +GFL +GFLW +GFR +GFS +GGAL +GGB +GGG +GGLL +GGLS +GGR +GGROW +GGT +GGT-E +GGT-G +GGZ +GH +GHC +GHG +GHI +GHLD +GHM +GHRS +GHY +GIB +GIBO +GIBOW +GIC +GIFI +GIFT +GIG +GIGGU +GIGGW +GIGM +GIII +GIL +GILD +GILT +GIND +GINX +GIPR +GIPRW +GIS +GITS +GJH +GJO +GJP +GJR +GJS +GJT +GKAT +GKOS +GL +GL-D +GLAD +GLADZ +GLBE +GLBS +GLBZ +GLCR +GLD +GLDD +GLDI +GLDY +GLE +GLGG +GLIBA +GLIBK +GLMD +GLNG +GLOB +GLOW +GLP +GLP-B +GLPG +GLPI +GLRE +GLSI +GLTO +GLUE +GLW +GLXG +GLXY +GM +GMAB +GME +GMED +GMGI +GMHS +GMM +GMRE +GNE +GNFT +GNK +GNL +GNL-A +GNL-B +GNL-D +GNL-E +GNLN +GNLX +GNMA +GNOM +GNPX +GNRC +GNSS +GNT +GNT-A +GNTA +GNTX +GNTY +GNW +GO +GOCO +GOEV +GOF +GOGO +GOLD +GOLF +GOOD +GOODN +GOODO +GOOG +GOOGL +GOOS +GORV +GOSS +GOTU +GOVI +GOVX +GOVXW +GP +GPAT +GPATU +GPATW +GPC +GPCR +GPI +GPIQ +GPIX +GPJA +GPK +GPMT +GPN +GPOR +GPRE +GPRF +GPRK +GPRO +GPS +GQQQ +GRAB +GRABW +GRAL +GRAN +GRBK +GRC +GRCE +GRDN +GREE +GREEL +GRFS +GRI +GRID +GRIN +GRMN +GRND +GRNQ +GRNT +GROV +GROW +GRPN +GRRR +GRRRW +GRVY +GRW +GRWG +GRX +GS +GS-A +GS-C +GS-D +GSAT +GSBC +GSBD +GSHD +GSHR +GSHRU +GSHRW +GSIB +GSIT +GSIW +GSK +GSL +GSL-B +GSM +GSRFU +GSRT +GSRTR +GSRTU +GSUN +GT +GTBP +GTEC +GTEN +GTENU +GTENW +GTERA +GTERR +GTERU +GTERW +GTES +GTI +GTIM +GTLB +GTLS +GTM +GTN +GTN.A +GTR +GTX +GTY +GUG +GURE +GUT +GUT-C +GUTS +GV +GVA +GVH +GWAV +GWH +GWRE +GWRS +GWW +GXAI +GXDW +GXO +GYLD +GYRE +GYRO +H +HAE +HAFC +HAFN +HAIN +HAL +HALO +HAO +HAS +HASI +HAYW +HBAN +HBANL +HBANM +HBANP +HBB +HBCP +HBDC +HBI +HBIO +HBM +HBNB +HBNC +HBT +HCA +HCAI +HCAT +HCC +HCHL +HCI +HCKT +HCM +HCMAU +HCOW +HCSG +HCTI +HCWB +HCXY +HD +HDB +HDL +HDSN +HDV +HE +HEAL +HECO +HEI +HEI.A +HEJD +HELE +HEPS +HEQ +HEQQ +HERD +HERO +HERZ +HESM +HEXO +HF +HFBL +HFFG +HFGM +HFND +HFRO +HFSP +HFWA +HG +HGBL +HGER +HGLB +HGTY +HGV +HHH +HHS +HI +HIDE +HIFS +HIG +HIG-G +HIHO +HII +HIMS +HIMX +HIMY +HIMZ +HIND +HIO +HIPO +HISF +HIT +HITI +HIVE +HIW +HIX +HKD +HKIT +HKPD +HL +HL-B +HLAL +HLF +HLI +HLIO +HLIT +HLLY +HLMN +HLN +HLNE +HLP +HLT +HLVX +HLX +HMC +HMN +HMR +HMY +HNDL +HNGE +HNI +HNNA +HNNAZ +HNRG +HNST +HNVR +HOFT +HOG +HOLO +HOLOW +HOLX +HOMB +HON +HOND +HONDU +HONDW +HONE +HOOD +HOOG +HOOI +HOOX +HOPE +HOTH +HOUR +HOUS +HOV +HOVNP +HOVR +HOVRW +HOWL +HP +HPAI +HPAIW +HPE +HPE-C +HPF +HPI +HPK +HPP +HPP-C +HPQ +HPS +HQGO +HQH +HQI +HQL +HQY +HR +HRB +HRI +HRL +HRMY +HROW +HROWL +HROWM +HRTG +HRTS +HRTX +HRZN +HSAI +HSBC +HSCS +HSCSW +HSDT +HSHP +HSIC +HSII +HSPO +HSPOR +HSPOU +HSPOW +HSPT +HSPTR +HSPTU +HST +HSTM +HSY +HTB +HTBK +HTCO +HTCR +HTD +HTFB +HTFC +HTFL +HTGC +HTH +HTHIY +HTHT +HTLD +HTLM +HTO +HTOO +HTOOW +HTZ +HTZWW +HUBB +HUBC +HUBCW +HUBCZ +HUBG +HUBS +HUDI +HUHU +HUIZ +HUM +HUMA +HUMAW +HUN +HURA +HURC +HURN +HUT +HUYA +HVII +HVIIR +HVIIU +HVMCU +HVT +HVT.A +HWAY +HWBK +HWC +HWCPZ +HWH +HWKN +HWM +HWSM +HXHX +HXL +HY +HYAC +HYBI +HYBX +HYDR +HYEM +HYFM +HYFT +HYG +HYI +HYLN +HYLS +HYMC +HYMCL +HYPD +HYPR +HYT +HYTR +HYXF +HYZD +HZO +IAC +IAE +IAG +IART +IAS +IAU +IBAC +IBACR +IBAT +IBB +IBBQ +IBCP +IBEX +IBG +IBGA +IBGB +IBGK +IBGL +IBIO +IBIT +IBKR +IBM +IBN +IBOC +IBOT +IBP +IBRX +IBTA +IBTF +IBTG +IBTH +IBTI +IBTJ +IBTK +IBTL +IBTM +IBTO +IBTP +IBTQ +ICCC +ICCM +ICE +ICFI +ICG +ICHR +ICL +ICLN +ICLR +ICMB +ICON +ICOP +ICR-A +ICU +ICUCW +ICUI +IDA +IDAI +IDCC +IDE +IDEF +IDN +IDT +IDU +IDXX +IDYA +IEF +IEFA +IEI +IEMG +IEP +IESC +IEUS +IEX +IFBD +IFF +IFGL +IFLO +IFN +IFRX +IFS +IFV +IGA +IGCB +IGD +IGF +IGI +IGIB +IGIC +IGOV +IGR +IGSB +IH +IHD +IHG +IHRT +IHS +IHYF +IIF +III +IIIN +IIIV +IIM +IINN +IINNW +IIPR +IJH +IJR +IJT +IKT +ILAG +ILIT +ILLR +ILLRW +ILMN +ILPT +IMA +IMAB +IMAX +IMCC +IMCR +IMCV +IMDX +IMG +IMKTA +IMMP +IMMR +IMMX +IMNM +IMNN +IMOM +IMOS +IMPP +IMPPP +IMRN +IMRX +IMTE +IMTX +IMUX +IMVT +IMXI +INAB +INAC +INACR +INACU +INBK +INBKZ +INBS +INBX +INCR +INCY +INDA +INDB +INDH +INDI +INDP +INDV +INDY +INEO +INFA +INFR +INFY +ING +INGM +INGN +INGR +INHD +INKT +INLF +INM +INMB +INMD +INN +INN-E +INN-F +INNV +INO +INOD +INR +INRO +INSE +INSG +INSM +INSP +INSW +INTA +INTC +INTG +INTJ +INTR +INTS +INTU +INTW +INTZ +INV +INVA +INVE +INVH +INVX +INVZ +INVZW +IOBT +IONL +IONQ +IONR +IONS +IONX +IONZ +IOSP +IOT +IOTR +IOVA +IP +IPAR +IPB +IPCX +IPCXR +IPCXU +IPDN +IPG +IPGP +IPHA +IPI +IPKW +IPM +IPOD +IPODU +IPODW +IPOE +IPOF +IPSC +IPW +IPWR +IPX +IQ +IQI +IQQQ +IQST +IQV +IR +IRBT +IRD +IRDM +IREN +IRIX +IRM +IRMD +IROH +IROHR +IROHU +IROHW +IRON +IROQ +IRS +IRT +IRTC +IRWD +ISBA +ISD +ISHG +ISHP +ISPC +ISPO +ISPOW +ISPR +ISRG +ISRL +ISRLU +ISRLW +ISSC +ISTB +ISTR +IT +ITB +ITGR +ITIC +ITRI +ITRM +ITRN +ITT +ITUB +ITW +IUS +IUSB +IUSG +IUSV +IVA +IVAL +IVDA +IVDAW +IVE +IVF +IVP +IVR +IVR-C +IVT +IVV +IVVD +IVW +IVZ +IWM +IX +IXHL +IXUS +IYC +IYE +IYF +IYH +IYJ +IYK +IYM +IYR +IYW +IZEA +IZM +J +JACK +JACS +JAGX +JAKK +JAMF +JANX +JAPN +JAZZ +JBDI +JBGS +JBHT +JBI +JBIO +JBK +JBL +JBLU +JBND +JBS +JBSS +JBTM +JCAP +JCE +JCI +JCSE +JCTC +JD +JDOC +JDZG +JEF +JELD +JEM +JENA +JEPQ +JEQ +JETS +JFB +JFBR +JFBRW +JFIN +JFR +JFU +JG +JGH +JGLO +JHAI +JHG +JHI +JHS +JHX +JILL +JIVE +JJSF +JKHY +JKS +JL +JLHL +JLL +JLS +JMIA +JMID +JMM +JMSB +JNJ +JNK +JO +JOBY +JOE +JOF +JOUT +JOYY +JPC +JPEF +JPI +JPM +JPM-C +JPM-D +JPM-J +JPM-K +JPM-L +JPM-M +JPST +JPX +JPY +JQC +JRI +JRS +JRSH +JRVR +JSM +JSMD +JSML +JSPR +JSPRW +JTAI +JTEK +JUNS +JVA +JWEL +JWN +JXG +JXN +JXN-A +JYD +JYNT +JZ +JZXN +K +KAI +KALA +KALU +KALV +KAR +KARO +KAT +KAVL +KB +KBAB +KBDC +KBH +KBR +KBSX +KBWB +KBWD +KBWP +KBWR +KBWY +KC +KCHV +KCHVR +KCHVU +KD +KDP +KE +KEAT +KELYA +KELYB +KEN +KEP +KEQU +KEX +KEY +KEY-I +KEY-J +KEY-K +KEY-L +KEYS +KF +KFFB +KFII +KFIIR +KFIIU +KFRC +KFS +KFY +KG +KGC +KGEI +KGS +KHC +KIDS +KIDZ +KIDZW +KIM +KIM-L +KIM-M +KIM-N +KINS +KIO +KITT +KITTW +KKR +KKR-D +KKRS +KKRT +KLAC +KLC +KLG +KLIC +KLRS +KLTO +KLTOW +KLTR +KLXE +KMB +KMDA +KMI +KMLI +KMPB +KMPR +KMRK +KMT +KMTS +KMX +KN +KNDI +KNF +KNGZ +KNOP +KNSA +KNSL +KNTK +KNX +KO +KOD +KODK +KOF +KOID +KOP +KOPN +KORE +KOS +KOSS +KOYNU +KPDD +KPLT +KPLTW +KPRX +KPTI +KQQQ +KR +KRC +KREF +KRG +KRKR +KRMA +KRMD +KRMN +KRNT +KRNY +KRO +KROP +KROS +KRP +KRRO +KRT +KRUS +KRYS +KSCP +KSPI +KSS +KT +KTB +KTCC +KTF +KTH +KTN +KTOS +KTTA +KTTAW +KUKE +KURA +KVAC +KVACU +KVACW +KVHI +KVUE +KVYO +KW +KWEB +KWM +KWMWW +KWR +KXIN +KYIV +KYIVW +KYMR +KYN +KYTX +KZIA +KZR +L +LAB +LABD +LABU +LAC +LAD +LADR +LAES +LAKE +LAMR +LAND +LANDM +LANDO +LANDP +LANV +LAR +LARK +LASE +LASR +LAUR +LAW +LAWR +LAYS +LAZ +LAZR +LB +LBGJ +LBRDA +LBRDK +LBRDP +LBRT +LBTYA +LBTYB +LBTYK +LC +LCCC +LCCCR +LCCCU +LCDL +LCDS +LCFY +LCFYW +LCID +LCII +LCNB +LCUT +LDEM +LDI +LDOS +LDP +LDRX +LDSF +LDWY +LE +LEA +LECO +LEDS +LEE +LEG +LEGH +LEGN +LEGR +LEN +LEN.B +LENZ +LEO +LESL +LEVI +LEXI +LEXX +LEXXW +LFCR +LFMD +LFMDP +LFSC +LFST +LFT +LFT-A +LFUS +LFVN +LFWD +LGCB +LGCF +LGCL +LGHL +LGI +LGIH +LGND +LGO +LGRO +LGVN +LH +LHAI +LHSW +LHX +LI +LICN +LIDR +LIDRW +LIEN +LIF +LII +LILA +LILAK +LIMN +LIMNW +LIN +LINC +LIND +LINE +LINK +LION +LIQT +LITB +LITE +LITM +LITP +LIVE +LIVN +LIVR +LIXT +LIXTW +LKFN +LKQ +LLY +LLYVA +LLYVK +LLYZ +LMAT +LMB +LMBS +LMFA +LMND +LMNR +LMT +LMTL +LMTS +LNC +LNC-D +LND +LNG +LNKB +LNKS +LNN +LNSR +LNT +LNTH +LNW +LNZA +LNZAW +LOAN +LOAR +LOB +LOB-A +LOBO +LOCL +LOCO +LOGI +LOGO +LOKV +LOKVU +LOKVW +LOMA +LOOP +LOPE +LOT +LOTWW +LOVE +LOW +LPAA +LPAAU +LPAAW +LPBB +LPBBU +LPBBW +LPCN +LPG +LPL +LPLA +LPRO +LPSN +LPTH +LPTX +LPX +LQD +LQDA +LQDT +LRCX +LRE +LRGE +LRHC +LRMR +LRN +LRND +LSAK +LSB +LSBK +LSBPW +LSCC +LSE +LSH +LSPD +LSTA +LSTR +LTBR +LTC +LTH +LTM +LTRN +LTRX +LTRYW +LU +LUCD +LUCK +LUCY +LUCYW +LULU +LUMN +LUNG +LUNR +LUV +LUXE +LVHD +LVLU +LVO +LVRO +LVROW +LVS +LVTX +LVWR +LW +LWAC +LWACU +LWACW +LWAY +LWLG +LX +LXEH +LXEO +LXFR +LXP +LXP-C +LXRX +LXU +LYB +LYEL +LYFT +LYG +LYRA +LYTS +LYV +LZ +LZB +LZM +LZMH +M +MA +MAA +MAA-I +MAAS +MAC +MACI +MACIU +MACIW +MAGH +MAGN +MAIN +MAMA +MAMK +MAMO +MAN +MANH +MANU +MAPS +MAPSW +MAR +MARA +MARPS +MAS +MASI +MASK +MASS +MAT +MATH +MATV +MATW +MATX +MAX +MAXI +MAXN +MAYA +MAYAR +MAYAU +MAYS +MAZE +MB +MBAV +MBAVU +MBAVW +MBB +MBBC +MBC +MBCN +MBFJF +MBI +MBIN +MBINL +MBINM +MBINN +MBIO +MBLY +MBNKO +MBOT +MBRX +MBS +MBUU +MBVIU +MBWM +MBX +MC +MCB +MCBS +MCD +MCDS +MCFT +MCHB +MCHI +MCHP +MCHPP +MCHS +MCHX +MCI +MCK +MCN +MCO +MCR +MCRB +MCRI +MCS +MCSE +MCTR +MCW +MCY +MD +MDAI +MDAIW +MDB +MDBH +MDCX +MDCXW +MDGL +MDIA +MDIV +MDLZ +MDRR +MDST +MDT +MDU +MDV +MDV-A +MDWD +MDXG +MDXH +MEC +MED +MEDP +MEDX +MEG +MEGI +MEGL +MEI +MEIP +MELI +MEMS +MENS +MEOH +MER-K +MERC +MESA +MESO +MET +MET-A +MET-E +MET-F +META +METC +METCB +METCI +METCZ +METD +METU +MFA +MFA-B +MFA-C +MFAN +MFAO +MFC +MFG +MFH +MFI +MFIC +MFICL +MFIN +MFLX +MFM +MFSB +MFSG +MFSI +MFSM +MFSV +MG +MGA +MGEE +MGF +MGIC +MGIH +MGM +MGNI +MGNX +MGPI +MGR +MGRB +MGRC +MGRD +MGRE +MGRM +MGRT +MGRX +MGTX +MGX +MGY +MGYR +MH +MHD +MHF +MHK +MHLA +MHN +MHNC +MHO +MHUA +MIAX +MIDD +MIGI +MILN +MIMI +MIN +MIND +MINT +MIR +MIRA +MIRM +MIST +MITK +MITN +MITP +MITT +MIY +MJID +MKAM +MKC +MKC.V +MKDW +MKDWW +MKL +MKLYU +MKSI +MKTW +MKTX +MKZR +MLAB +MLAC +MLACR +MLACU +MLCO +MLEC +MLECW +MLGO +MLI +MLKN +MLM +MLNK +MLP +MLR +MLTX +MLYS +MMC +MMD +MMI +MMKT +MMLP +MMM +MMS +MMSI +MMT +MMU +MMYT +MNDO +MNDR +MNDY +MNKD +MNMD +MNOV +MNPR +MNR +MNRO +MNSB +MNSBP +MNSO +MNST +MNTK +MNTN +MNTS +MNTSW +MNY +MNYWW +MO +MOB +MOBBW +MOBX +MOBXW +MOD +MODD +MODG +MODL +MOFG +MOG.A +MOG.B +MOGO +MOGU +MOH +MOLN +MOMO +MOOD +MORN +MORT +MOS +MOV +MOVE +MP +MPA +MPAA +MPB +MPC +MPLX +MPV +MPW +MPWR +MPX +MQ +MQQQ +MQT +MQY +MRAL +MRAM +MRBK +MRC +MRCC +MRCY +MREO +MRK +MRKR +MRM +MRNA +MRNO +MRNOW +MRP +MRSN +MRTN +MRUS +MRVI +MRVL +MRX +MS +MS-A +MS-E +MS-F +MS-I +MS-K +MS-L +MS-O +MS-P +MS-Q +MSA +MSAI +MSAIW +MSB +MSBI +MSBIP +MSC +MSCI +MSD +MSDD +MSDL +MSEX +MSFD +MSFL +MSFT +MSFU +MSGE +MSGM +MSGS +MSGY +MSI +MSIF +MSM +MSPR +MSPRW +MSPRZ +MSS +MST +MSTP +MSTR +MSTX +MSW +MT +MTAL +MTB +MTB-H +MTB-J +MTC +MTCH +MTD +MTDR +MTEK +MTEKW +MTEN +MTEX +MTG +MTH +MTLS +MTN +MTR +MTRN +MTRX +MTSI +MTSR +MTUM +MTUS +MTVA +MTW +MTX +MTZ +MU +MUA +MUB +MUC +MUD +MUE +MUFG +MUJ +MULL +MULT +MUR +MURA +MUSA +MUSE +MUU +MUX +MVBF +MVF +MVIS +MVLL +MVO +MVST +MVSTW +MVT +MWA +MWYN +MX +MXCT +MXE +MXF +MXL +MYCF +MYCG +MYCH +MYCI +MYCJ +MYCK +MYCL +MYCM +MYCN +MYD +MYE +MYFW +MYGN +MYI +MYMF +MYMG +MYMH +MYMI +MYMJ +MYN +MYNZ +MYPS +MYPSW +MYRG +MYSE +MYSEW +MYSZ +MZTI +NAAS +NABL +NAC +NAD +NAGE +NAII +NAKA +NAMI +NAMM +NAMMW +NAMS +NAMSW +NAN +NAOV +NAT +NATH +NATL +NATO +NATR +NAUT +NAVI +NAZ +NB +NBB +NBBK +NBHC +NBIS +NBIX +NBN +NBR +NBTB +NBTX +NBXG +NC +NCA +NCDL +NCEW +NCI +NCIQ +NCLH +NCMI +NCNA +NCNO +NCPB +NCPL +NCPLW +NCRA +NCSM +NCT +NCTY +NCV +NCV-A +NCZ +NCZ-A +NDAA +NDAQ +NDLS +NDMO +NDRA +NDSN +NE +NEA +NEAR +NECB +NEE +NEE-N +NEE-S +NEE-T +NEE-U +NEGG +NEM +NEO +NEOG +NEON +NEOV +NEOVW +NEPH +NERD +NERV +NESR +NET +NETD +NETDU +NETDW +NEU +NEUE +NEUP +NEWT +NEWTG +NEWTH +NEWTI +NEWTP +NEWTZ +NEWZ +NEXA +NEXM +NEXN +NEXT +NFBK +NFE +NFG +NFJ +NFLX +NFTY +NFXL +NFXS +NGG +NGL +NGL-B +NGL-C +NGNE +NGS +NGVC +NGVT +NHI +NHIC +NHICU +NHICW +NHPAP +NHPBP +NHTC +NI +NIB +NIC +NICE +NIE +NIKL +NIM +NINE +NIO +NIOBW +NIPG +NIQ +NISN +NITO +NIU +NIVF +NIVFW +NIXT +NIXX +NIXXW +NJR +NKE +NKLA +NKSH +NKTR +NKTX +NKX +NL +NLOP +NLSP +NLSPW +NLY +NLY-F +NLY-G +NLY-I +NLY-J +NMAI +NMAX +NMCO +NMFC +NMFCZ +NMG +NMI +NMIH +NMM +NMP +NMPAR +NMPAU +NMR +NMRA +NMRK +NMS +NMT +NMTC +NMZ +NN +NNAVW +NNBR +NNDM +NNE +NNI +NNN +NNNN +NNOX +NNY +NOA +NOAH +NOBL +NOC +NODK +NOEM +NOEMR +NOEMU +NOEMW +NOG +NOK +NOM +NOMD +NOTE +NOTV +NOV +NOVT +NOW +NOWL +NPAC +NPACU +NPACW +NPB +NPCE +NPCT +NPFD +NPFI +NPK +NPKI +NPO +NPV +NPWR +NQP +NRC +NRDS +NRDY +NREF +NRES +NRG +NRGV +NRIM +NRIX +NRK +NRP +NRSN +NRSNW +NRT +NRUC +NRXP +NRXPW +NSA +NSA-A +NSA-B +NSANY +NSC +NSCR +NSI +NSIT +NSP +NSPR +NSSC +NSTS +NSYS +NTAP +NTB +NTCL +NTCT +NTES +NTEST +NTGR +NTHI +NTIC +NTLA +NTNX +NTR +NTRA +NTRB +NTRBW +NTRP +NTRS +NTRSO +NTST +NTT +NTWK +NTWO +NTWOU +NTWOW +NTZ +NU +NUAI +NUAIW +NUE +NUKK +NUKKW +NUS +NUSB +NUTR +NUTX +NUV +NUVB +NUVL +NUW +NUWE +NVA +NVAWW +NVAX +NVCR +NVCT +NVD +NVDA +NVDD +NVDG +NVDL +NVDS +NVDU +NVEC +NVFY +NVG +NVGS +NVMI +NVNI +NVNIW +NVNO +NVO +NVR +NVRI +NVS +NVST +NVT +NVTS +NVVE +NVVEW +NVX +NVYY +NWBI +NWE +NWFL +NWG +NWGL +NWL +NWN +NWPX +NWS +NWSA +NWTG +NX +NXC +NXDR +NXDT +NXE +NXG +NXGL +NXGLW +NXJ +NXL +NXLIW +NXN +NXP +NXPI +NXPL +NXPLW +NXRT +NXST +NXT +NXTC +NXTG +NXTT +NXXT +NYAX +NYC +NYT +NYXH +NZAC +NZF +NZUS +O +OABI +OABIW +OACC +OACCU +OACCW +OAK-A +OAK-B +OAKU +OAKUR +OAKUU +OAKUW +OBA +OBAWU +OBAWW +OBDC +OBIL +OBIO +OBK +OBLG +OBT +OC +OCC +OCCI +OCCIM +OCCIN +OCCIO +OCFC +OCFT +OCG +OCGN +OCS +OCSAW +OCSL +OCTO +OCUL +ODC +ODD +ODDS +ODFL +ODP +ODV +ODVWZ +ODYS +OEC +OESX +OFAL +OFG +OFIX +OFLX +OFS +OFSSH +OFSSO +OGE +OGI +OGN +OGS +OGZPY +OHI +OI +OIA +OII +OIS +OKE +OKLL +OKLO +OKTA +OKUR +OKYO +OLB +OLED +OLLI +OLMA +OLN +OLO +OLP +OLPX +OM +OMAB +OMC +OMCC +OMCL +OMDA +OMER +OMEX +OMF +OMH +OMI +OMSE +ON +ONB +ONBPO +ONBPP +ONC +ONCHU +ONCO +ONCY +ONDS +ONEG +ONEQ +ONEW +ONFO +ONFOW +ONIT +ONL +ONMD +ONMDW +ONON +ONTF +ONTO +OOMA +OOQB +OOSB +OP +OPAD +OPAL +OPBK +OPCH +OPEN +OPFI +OPI +OPINL +OPK +OPP +OPP-A +OPP-B +OPPJ +OPRA +OPRT +OPRX +OPT +OPTX +OPTXW +OPTZ +OPXS +OPY +OR +ORA +ORC +ORCL +ORCX +ORGN +ORGNW +ORGO +ORI +ORIC +ORIQU +ORIS +ORKA +ORKT +ORLY +ORMP +ORN +ORR +ORRF +OS +OSBC +OSCR +OSIS +OSK +OSPN +OSRH +OSRHW +OSS +OST +OSUR +OSW +OTEX +OTF +OTGL +OTIS +OTLK +OTLY +OTTR +OUST +OUSTW +OUSTZ +OUT +OVBC +OVID +OVLY +OVV +OWL +OWLT +OXBR +OXBRW +OXLC +OXLCG +OXLCI +OXLCL +OXLCN +OXLCO +OXLCP +OXLCZ +OXM +OXSQ +OXSQG +OXSQH +OXSQZ +OXY +OYSE +OYSER +OYSEU +OZEM +OZK +OZKAP +PAA +PAAS +PABD +PABU +PAC +PACB +PACH +PACHU +PACHW +PACK +PACS +PAG +PAGP +PAGS +PAHC +PAI +PAL +PALD +PALI +PALU +PAM +PAMT +PANG +PANL +PANW +PAR +PARR +PASG +PATH +PATK +PATN +PAVM +PAVS +PAX +PAXS +PAY +PAYC +PAYO +PAYS +PAYX +PB +PBA +PBBK +PBF +PBFS +PBH +PBHC +PBI +PBI-B +PBM +PBMWW +PBPB +PBQQ +PBR +PBR-A +PBR.A +PBT +PBW +PBYI +PC +PCAP +PCAPU +PCAPW +PCAR +PCB +PCF +PCG +PCG-X +PCH +PCLA +PCM +PCMM +PCN +PCOR +PCQ +PCRX +PCSA +PCSC +PCT +PCTTU +PCTTW +PCTY +PCVX +PCY +PCYO +PD +PDBA +PDBC +PDCC +PDD +PDDL +PDEX +PDFS +PDI +PDLB +PDM +PDO +PDP +PDPA +PDS +PDSB +PDT +PDX +PDYN +PDYNW +PEB +PEB-E +PEB-F +PEB-G +PEB-H +PEBK +PEBO +PECO +PEG +PEGA +PELI +PELIR +PELIU +PEN +PENG +PENN +PEO +PEP +PEPG +PEPS +PERF +PERI +PESI +PETS +PETZ +PEW +PEY +PEZ +PFAI +PFBC +PFD +PFE +PFF +PFG +PFGC +PFH +PFI +PFIS +PFL +PFLT +PFM +PFN +PFO +PFS +PFSA +PFSI +PFX +PFXNZ +PG +PGAC +PGACR +PGACU +PGC +PGEN +PGJ +PGNY +PGP +PGR +PGRE +PGY +PGYWW +PGZ +PH +PHAR +PHAT +PHD +PHG +PHH +PHI +PHIN +PHIO +PHK +PHLT +PHM +PHO +PHOE +PHR +PHT +PHUN +PHVS +PI +PID +PIE +PII +PIII +PIIIW +PIM +PINC +PINE +PINS +PIO +PIPR +PIZ +PJT +PK +PKBK +PKE +PKG +PKOH +PKST +PKW +PKX +PL +PLAB +PLAY +PLBC +PLBL +PLBY +PLCE +PLD +PLMK +PLMKU +PLMKW +PLMR +PLNT +PLOW +PLPC +PLRX +PLRZ +PLSE +PLT +PLTD +PLTG +PLTK +PLTR +PLTU +PLTZ +PLUG +PLUR +PLUS +PLUT +PLXS +PLYM +PM +PMAX +PMBS +PMCB +PMEC +PML +PMM +PMN +PMO +PMT +PMT-A +PMT-B +PMT-C +PMTR +PMTRU +PMTRW +PMTS +PMTU +PMTV +PMTW +PMVP +PN +PNBK +PNC +PNFP +PNFPP +PNI +PNNT +PNQI +PNR +PNRG +PNTG +PNW +POAI +POCI +PODC +PODD +POET +POLA +POLE +POLEU +POLEW +PONY +POOL +POR +POST +POWI +POWL +POWW +POWWP +PPBT +PPC +PPCB +PPG +PPH +PPI +PPIH +PPL +PPSI +PPT +PPTA +PQAP +PQJA +PQJL +PQOC +PR +PRA +PRAA +PRAX +PRCH +PRCS +PRCT +PRDO +PRE +PRENW +PRFX +PRFZ +PRG +PRGO +PRGS +PRH +PRI +PRIM +PRKS +PRLB +PRLD +PRM +PRMB +PRME +PRN +PRO +PROF +PROK +PROP +PROV +PRPH +PRPL +PRPO +PRQR +PRS +PRSO +PRSU +PRT +PRTA +PRTC +PRTH +PRTS +PRU +PRVA +PRVS +PRZO +PSA +PSA-F +PSA-G +PSA-H +PSA-I +PSA-J +PSA-K +PSA-L +PSA-M +PSA-N +PSA-O +PSA-P +PSA-Q +PSA-R +PSA-S +PSBD +PSC +PSCC +PSCD +PSCE +PSCF +PSCH +PSCI +PSCM +PSCT +PSCU +PSEC +PSET +PSF +PSFE +PSHG +PSIG +PSIX +PSKY +PSL +PSMT +PSN +PSNL +PSNY +PSNYW +PSO +PSQH +PSTG +PSTH +PSTL +PSTR +PSTV +PSWD +PSX +PT +PTA +PTC +PTCT +PTEN +PTF +PTGX +PTH +PTHL +PTIR +PTIX +PTIXW +PTLE +PTLO +PTNM +PTNQ +PTON +PTY +PUBM +PUI +PUK +PULM +PUMP +PVBC +PVH +PVL +PVLA +PWM +PWP +PWR +PWRD +PX +PXD +PXI +PXLW +PXS +PXSAW +PY +PYPD +PYPG +PYPL +PYT +PYXS +PYZ +PZZA +QABA +QALT +QAT +QB +QBIG +QBTS +QBUF +QCLN +QCLR +QCMD +QCML +QCMU +QCOM +QCRH +QD +QDEL +QDTY +QETA +QETAR +QETAU +QFIN +QGEN +QGRD +QH +QHDG +QIPT +QLGN +QLYS +QMCO +QMID +QMMM +QMOM +QNCX +QNRX +QNST +QNTM +QNXT +QOWZ +QPUX +QQA +QQDN +QQEW +QQHG +QQJG +QQLV +QQMG +QQQ +QQQA +QQQE +QQQG +QQQH +QQQI +QQQJ +QQQM +QQQP +QQQS +QQQT +QQQX +QQQY +QQUP +QQWZ +QQXL +QQXT +QRHC +QRMI +QRVO +QS +QSEA +QSEAR +QSEAU +QSG +QSI +QSIAW +QSIX +QSML +QSR +QTEC +QTOP +QTR +QTRX +QTTB +QTUM +QTWO +QUAD +QUAL +QUBT +QUIK +QUMSU +QURE +QVAL +QVCC +QVCD +QVCGA +QVCGP +QXO +QXO-B +QXQ +QYLD +QYLG +R +RA +RAA +RAAQ +RAAQU +RAAQW +RAC +RACE +RADX +RAIL +RAIN +RAINW +RAL +RAMP +RAND +RANG +RANGR +RANGU +RANI +RAPP +RAPT +RARE +RAVE +RAY +RAYA +RBA +RBB +RBBN +RBC +RBCAA +RBIL +RBKB +RBLX +RBNE +RBOT +RBRK +RC +RC-C +RC-E +RCAT +RCB +RCC +RCD +RCEL +RCGE +RCI +RCKT +RCKTW +RCKY +RCL +RCMT +RCON +RCS +RCT +RCUS +RDAC +RDACR +RDACU +RDAG +RDAGU +RDAGW +RDCM +RDDT +RDGT +RDHL +RDI +RDIB +RDN +RDNT +RDNW +RDTL +RDTY +RDVT +RDVY +RDW +RDWR +RDY +RDZN +RDZNW +REAI +REAL +REAX +REBN +RECT +REDF +REE +REFI +REFR +REG +REGCO +REGCP +REGN +REIT +REKR +RELI +RELIW +RELL +RELX +RELY +REM +REMG +RENB +RENT +REPL +RERE +RES +RETO +REVB +REVBW +REVG +REX +REXR +REYN +REZ +REZI +RF +RF-C +RF-E +RF-F +RFAI +RFAIR +RFAIU +RFDI +RFEM +RFEU +RFI +RFIL +RFL +RFM +RFMZ +RGA +RGC +RGCO +RGEN +RGLD +RGLO +RGNX +RGP +RGR +RGS +RGT +RGTI +RGTIW +RGTX +RH +RHI +RHLD +RHP +RIBB +RIBBR +RIBBU +RICK +RIDE +RIFR +RIG +RIGL +RILY +RILYG +RILYK +RILYL +RILYN +RILYP +RILYT +RILYZ +RIME +RING +RINT +RIO +RIOT +RITM +RITR +RIV +RIV-A +RIVN +RJF +RJF-B +RKDA +RKLB +RKLX +RKT +RL +RLAY +RLI +RLJ +RLJ-A +RLMD +RLTY +RLX +RLYB +RM +RMAX +RMBI +RMBS +RMCF +RMCO +RMCOW +RMD +RMI +RMM +RMMZ +RMNI +RMR +RMSG +RMSGW +RMT +RMTI +RNA +RNAC +RNAZ +RNEM +RNG +RNGR +RNIN +RNP +RNR +RNR-F +RNR-G +RNRG +RNST +RNTX +RNW +RNWWW +RNXT +ROAD +ROBT +ROCK +ROE +ROG +ROIV +ROK +ROKU +ROL +ROMA +ROOT +ROP +ROST +RPAY +RPD +RPID +RPM +RPRX +RPT +RPT-C +RPTX +RQI +RR +RRBI +RRC +RRGB +RRR +RRX +RS +RSF +RSG +RSI +RSKD +RSSS +RSVR +RSVRW +RSX +RTAC +RTACU +RTACW +RTH +RTO +RTX +RTXG +RUBI +RUM +RUMBW +RUN +RUNN +RUSC +RUSHA +RUSHB +RVLV +RVMD +RVMDW +RVNL +RVPH +RVPHW +RVSB +RVSN +RVSNW +RVT +RVTY +RVYL +RWAY +RWAYL +RWAYZ +RWT +RWT-A +RWTN +RWTO +RWTP +RXL +RXO +RXRX +RXST +RXT +RY +RYAAY +RYAM +RYAN +RYET +RYI +RYM +RYN +RYOJ +RYTM +RZB +RZC +RZLT +RZLV +RZLVW +S +SA +SABA +SABR +SABS +SABSW +SAFE +SAFT +SAFX +SAGT +SAH +SAIA +SAIC +SAIH +SAIHW +SAIL +SAJ +SAM +SAMG +SAN +SANA +SAND +SANG +SANM +SAP +SAR +SARK +SARO +SAT +SATL +SATLW +SATS +SAVA +SAY +SAZ +SB +SB-C +SB-D +SBAC +SBC +SBCF +SBCWW +SBDS +SBE +SBET +SBFG +SBFM +SBFMW +SBGI +SBH +SBI +SBLK +SBLX +SBR +SBRA +SBS +SBSI +SBSW +SBUX +SBXD +SCAG +SCAGW +SCCO +SCD +SCDS +SCE-G +SCE-J +SCE-K +SCE-L +SCE-M +SCE-N +SCHA +SCHB +SCHD +SCHF +SCHH +SCHL +SCHW +SCHX +SCI +SCKT +SCL +SCLX +SCLXW +SCM +SCNI +SCNX +SCOR +SCPH +SCS +SCSC +SCVL +SCWO +SCYX +SCZ +SD +SDA +SDAWW +SDG +SDGR +SDHC +SDHI +SDHIR +SDHIU +SDHY +SDM +SDOT +SDOW +SDRL +SDSI +SDST +SDSTW +SDTY +SDVY +SE +SEAT +SEATW +SEDG +SEE +SEED +SEEM +SEER +SEG +SEGG +SEI +SEIC +SEIE +SEIS +SELF +SELX +SEM +SEMR +SENEA +SENEB +SEPN +SERA +SERV +SES +SETM +SEVN +SEZL +SF +SF-B +SF-C +SF-D +SFB +SFBC +SFBS +SFD +SFHG +SFIX +SFL +SFLO +SFM +SFNC +SFST +SFTBY +SFUNY +SFWL +SG +SGA +SGBX +SGC +SGD +SGEN +SGHC +SGHT +SGI +SGLY +SGML +SGMO +SGMT +SGRP +SGRY +SGU +SHAK +SHBI +SHC +SHCAY +SHCO +SHEL +SHEN +SHFS +SHFSW +SHG +SHIM +SHIP +SHLS +SHM +SHMD +SHMDW +SHO +SHO-H +SHO-I +SHOC +SHOO +SHOP +SHOT +SHOTW +SHPD +SHPH +SHPU +SHRY +SHV +SHW +SHY +SHYG +SI +SIBN +SID +SIDU +SIEB +SIFY +SIG +SIGA +SIGI +SIGIP +SII +SILA +SILC +SILO +SIMA +SIMAU +SIMAW +SIMO +SINT +SION +SIRI +SISI +SITC +SITE +SITM +SIXG +SIZE +SJ +SJCP +SJLD +SJM +SJT +SKBL +SKE +SKIL +SKIN +SKK +SKLZ +SKM +SKOR +SKRE +SKT +SKWD +SKX +SKY +SKYE +SKYH +SKYQ +SKYT +SKYU +SKYW +SKYX +SKYY +SLAB +SLB +SLDB +SLDE +SLDP +SLDPW +SLE +SLF +SLG +SLG-I +SLGL +SLGN +SLM +SLMBP +SLN +SLNG +SLNH +SLNHP +SLNO +SLNZ +SLP +SLQD +SLQT +SLRC +SLRX +SLS +SLSN +SLV +SLVM +SLVO +SLVR +SLXN +SLXNW +SM +SMA +SMBC +SMBK +SMC +SMCC +SMCF +SMCI +SMCL +SMCO +SMCX +SMCZ +SMFG +SMG +SMH +SMHI +SMHX +SMID +SMLR +SMMT +SMP +SMPL +SMR +SMRI +SMRT +SMSI +SMST +SMTC +SMTI +SMTK +SMWB +SMX +SMXT +SMXWW +SN +SNA +SNAL +SNAP +SNBR +SNCR +SNCY +SND +SNDA +SNDK +SNDL +SNDR +SNDX +SNES +SNEX +SNFCA +SNGX +SNN +SNOA +SNOW +SNPS +SNSE +SNSR +SNT +SNTG +SNTI +SNV +SNV-D +SNV-E +SNWV +SNX +SNY +SNYR +SO +SOBO +SOBR +SOC +SOCA +SOCAU +SOCAW +SOCL +SOFI +SOFX +SOGP +SOHO +SOHOB +SOHON +SOHOO +SOHU +SOJC +SOJD +SOJE +SOJF +SOL +SOLT +SOLV +SOLZ +SON +SOND +SONDW +SONM +SONN +SONO +SONY +SOPA +SOPH +SOR +SORA +SOS +SOTK +SOUL +SOUN +SOUNW +SOUX +SOWG +SOXL +SOXQ +SOXS +SOXX +SOYB +SPAI +SPAM +SPAQ +SPB +SPBC +SPC +SPCB +SPCE +SPCX +SPCY +SPE +SPE-C +SPEGU +SPFI +SPG +SPG-J +SPGI +SPH +SPHL +SPHR +SPIR +SPKL +SPKLU +SPKLW +SPMA +SPMC +SPME +SPNS +SPNT +SPOK +SPOT +SPPL +SPR +SPRC +SPRO +SPRU +SPRX +SPRY +SPSC +SPT +SPTN +SPWH +SPWR +SPWRW +SPXC +SPXD +SPXU +SPXX +SPY +SPYQ +SQ +SQFT +SQFTP +SQFTW +SQLV +SQM +SQNS +SQQQ +SR +SR-A +SRAD +SRBK +SRCE +SRDX +SRE +SREA +SRET +SRFM +SRG +SRG-A +SRI +SRL +SRPT +SRRK +SRTA +SRTAW +SRTS +SRV +SRZN +SRZNW +SSB +SSBI +SSD +SSEAU +SSII +SSKN +SSL +SSM +SSNC +SSP +SSRM +SSSS +SSSSL +SST +SSTI +SSTK +SSYS +ST +STAA +STAG +STAI +STAK +STBA +STC +STE +STEC +STEL +STEM +STEP +STEW +STFS +STG +STGW +STHO +STI +STIM +STK +STKH +STKL +STKS +STLA +STLD +STM +STN +STNC +STNE +STNG +STOK +STRA +STRC +STRD +STRF +STRK +STRL +STRO +STRR +STRRP +STRS +STRT +STRV +STRZ +STSS +STSSW +STT +STT-G +STTK +STVN +STWD +STX +STXD +STXE +STXG +STXI +STXK +STXM +STXT +STXV +STZ +SU +SUGP +SUI +SUIG +SUN +SUNE +SUNS +SUPN +SUPP +SUPV +SUPX +SURG +SUSB +SUSC +SUSL +SUUN +SUZ +SVA +SVACU +SVC +SVCC +SVCCU +SVCCW +SVCO +SVII +SVIIR +SVIIU +SVIIW +SVRA +SVRE +SVREW +SVV +SW +SWAG +SWAGW +SWBI +SWIM +SWIN +SWK +SWKH +SWKHL +SWKS +SWP +SWVL +SWVLW +SWX +SWZ +SXC +SXI +SXT +SXTC +SXTP +SXTPW +SY +SYBT +SYBX +SYF +SYF-A +SYF-B +SYK +SYM +SYNA +SYPR +SYRE +SYTA +SYTAW +SYY +SZZL +SZZLR +SZZLU +T +T-A +T-C +TAC +TACH +TACHU +TACHW +TACO +TACOU +TACOW +TACT +TAIT +TAK +TAL +TALK +TALKW +TALO +TANH +TAOP +TAOX +TAP +TAP.A +TARA +TARK +TARS +TASK +TATT +TAVI +TAVIR +TAVIU +TAX +TAXE +TAXI +TAXS +TAXT +TAYD +TBB +TBBB +TBBK +TBCH +TBH +TBHC +TBI +TBIL +TBLA +TBLAW +TBLD +TBLU +TBMC +TBMCR +TBN +TBPH +TBRG +TC +TCAI +TCBI +TCBIO +TCBK +TCBS +TCBX +TCHI +TCI +TCMD +TCOM +TCPC +TCRT +TCRX +TCX +TD +TDAC +TDACU +TDACW +TDC +TDF +TDG +TDI +TDIC +TDIV +TDOC +TDS +TDS-U +TDS-V +TDSB +TDSC +TDTH +TDUP +TDW +TDY +TE +TEAD +TEAF +TEAM +TECH +TECK +TECTP +TECX +TEF +TEI +TEKX +TEKY +TEL +TELA +TELO +TEM +TEN +TEN-E +TEN-F +TENB +TENX +TEO +TER +TERN +TEVA +TEX +TEXN +TFC +TFC-I +TFC-O +TFC-R +TFII +TFIN +TFIN- +TFNS +TFPM +TFSA +TFSL +TFX +TG +TGE +TGHL +TGL +TGLS +TGNA +TGS +TGT +TGTX +TH +THAR +THC +THCB +THCH +THFF +THG +THH +THIR +THLV +THMZ +THO +THQ +THR +THRM +THRY +THS +THTX +THW +TIC +TIGO +TIGR +TIL +TILE +TIMB +TIP +TIPT +TIRX +TISI +TITN +TIVC +TIXT +TJX +TK +TKC +TKLF +TKNO +TKO +TKOMY +TKR +TLF +TLIH +TLK +TLN +TLPH +TLRY +TLS +TLSA +TLSI +TLSIW +TLT +TLX +TLYS +TM +TMB +TMC +TMCI +TMCWW +TMDX +TME +TMED +TMET +TMHC +TMO +TMUS +TMUSI +TMUSL +TMUSZ +TNA +TNC +TNDM +TNET +TNFA +TNGX +TNGY +TNK +TNL +TNMG +TNON +TNONW +TNXP +TNYA +TOI +TOIIW +TOL +TOMZ +TONX +TOP +TORO +TOST +TOUR +TOWN +TOYO +TPB +TPC +TPCS +TPG +TPGXL +TPH +TPL +TPLS +TPR +TPST +TPTA +TPVG +TPYP +TPZ +TQQQ +TQQY +TR +TRAK +TRAW +TRC +TRDA +TREE +TREX +TRGP +TRI +TRIB +TRIN +TRINI +TRINZ +TRIP +TRMB +TRMD +TRMK +TRML +TRN +TRNO +TRNR +TRNS +TRON +TROO +TROW +TROX +TRP +TRS +TRSG +TRST +TRTX +TRU +TRUD +TRUE +TRUG +TRUP +TRUT +TRV +TRVG +TRVI +TS +TSAT +TSBK +TSCO +TSDD +TSE +TSEL +TSEM +TSHA +TSI +TSL +TSLA +TSLG +TSLL +TSLQ +TSLR +TSLS +TSLX +TSM +TSMG +TSMU +TSMX +TSMZ +TSN +TSPY +TSQ +TSSI +TSYY +TT +TTAM +TTAN +TTC +TTD +TTE +TTEC +TTEK +TTEQ +TTGT +TTI +TTM +TTMI +TTNP +TTSH +TTWO +TU +TUG +TUGN +TUR +TURB +TURF +TURN +TUSK +TUYA +TV +TVA +TVACU +TVACW +TVAI +TVAIR +TVAIU +TVC +TVE +TVGN +TVGNW +TVRD +TVTX +TW +TWFG +TWG +TWI +TWIN +TWLO +TWN +TWNP +TWO +TWO-A +TWO-B +TWO-C +TWOD +TWST +TX +TXG +TXMD +TXN +TXNM +TXO +TXRH +TXSS +TXT +TXUE +TXUG +TY +TY- +TYG +TYGO +TYL +TYRA +TZA +TZOO +TZUP +U +UA +UAA +UAE +UAL +UAN +UBCP +UBER +UBFO +UBND +UBRL +UBS +UBSI +UBXG +UCAR +UCB +UCB-I +UCL +UCRD +UCTT +UCYB +UDMY +UDOW +UDR +UE +UEIC +UEVM +UFCS +UFG +UFI +UFIV +UFO +UFPI +UFPT +UG +UGI +UGP +UGRO +UHAL +UHG +UHGWW +UHS +UHT +UI +UIS +UITB +UIVM +UK +UKOMW +UL +ULBI +ULCC +ULH +ULS +ULTA +ULVM +ULY +UMBF +UMBFO +UMC +UMH +UMH-D +UMMA +UNB +UNCY +UNF +UNFI +UNG +UNH +UNHG +UNIT +UNIY +UNM +UNMA +UNP +UNTY +UOKA +UONE +UONEK +UP +UPB +UPBD +UPC +UPGR +UPLD +UPRO +UPS +UPST +UPWK +UPXI +URA +URBN +URGN +URI +URNJ +UROY +USA +USAC +USAF +USAR +USARW +USAU +USB +USB-A +USB-H +USB-P +USB-Q +USB-R +USB-S +USCB +USCL +USDX +USEA +USEG +USFD +USFI +USGO +USGOW +USHY +USIG +USIN +USIO +USLM +USMC +USMV +USNA +USO +USOI +USOY +USPH +USRD +USSH +USTB +USVM +USVN +USXF +UTEN +UTF +UTHR +UTHY +UTI +UTL +UTMD +UTRE +UTSI +UTWO +UTWY +UTZ +UVE +UVSP +UVV +UWMC +UXIN +UYLD +UYSC +UYSCR +UYSCU +UZD +UZE +UZF +V +VABK +VAC +VACH +VACHU +VACHW +VAL +VALE +VALN +VALU +VANI +VATE +VAW +VBF +VBIL +VBIX +VBNK +VBTX +VC +VCEL +VCIC +VCICU +VCICW +VCIG +VCIT +VCLT +VCR +VCRB +VCSH +VCTR +VCV +VCYT +VDC +VDE +VEA +VECO +VEDL +VEEA +VEEAW +VEEE +VEEV +VEL +VELO +VEON +VERA +VERI +VERO +VERU +VERX +VET +VEU +VFC +VFF +VFH +VFLO +VFS +VFSWW +VG +VGAS +VGASW +VGI +VGIT +VGLT +VGM +VGSH +VGSR +VGT +VGUS +VHC +VHI +VHT +VIASP +VIAV +VICI +VICR +VIG +VIGI +VIK +VINP +VIOT +VIPS +VIR +VIRC +VIRT +VIS +VIST +VITL +VIV +VIVK +VIVS +VIXI +VKQ +VKTX +VLGEA +VLN +VLO +VLRS +VLT +VLTO +VLY +VLYPN +VLYPO +VLYPP +VMAR +VMBS +VMC +VMD +VMEO +VMI +VMO +VMOT +VNCE +VNDA +VNET +VNME +VNMEU +VNMEW +VNO +VNO-L +VNO-M +VNO-N +VNO-O +VNOM +VNQ +VNQI +VNT +VOC +VOD +VOLT +VONE +VONG +VONV +VOO +VOR +VOTE +VOXR +VOYA +VOYG +VPG +VPLS +VPU +VPV +VRA +VRAR +VRAX +VRCA +VRDN +VRE +VREX +VRIG +VRM +VRME +VRNA +VRNS +VRNT +VRRM +VRSK +VRSN +VRT +VRTL +VRTS +VRTX +VS +VSA +VSAT +VSCO +VSDA +VSEC +VSEE +VSEEW +VSH +VSME +VSMV +VSS +VSSYW +VST +VSTA +VSTD +VSTL +VSTM +VSTS +VTC +VTEB +VTEX +VTGN +VTHR +VTI +VTIP +VTLE +VTMX +VTN +VTOL +VTR +VTRS +VTS +VTSI +VTV +VTVT +VTWG +VTWO +VTWV +VTYX +VUG +VUZI +VVOS +VVPR +VVR +VVV +VVX +VWAV +VWAVW +VWO +VWOB +VXUS +VYGR +VYM +VYMI +VYNE +VYX +VZ +W +WAB +WABC +WABF +WAFD +WAFDP +WAFU +WAI +WAL +WAL-A +WALD +WALDW +WASH +WAT +WATT +WAVE +WAY +WB +WBD +WBS +WBS-F +WBS-G +WBTN +WBUY +WBX +WCBR +WCC +WCLD +WCN +WCT +WD +WDAY +WDC +WDFC +WDH +WDI +WDS +WEA +WEAT +WEAV +WEC +WEEI +WELL +WEN +WENN +WENNU +WENNW +WERN +WES +WEST +WETH +WETO +WEX +WEYS +WF +WFC +WFC-A +WFC-C +WFC-D +WFC-L +WFC-Y +WFC-Z +WFCF +WFF +WFG +WFRD +WGMI +WGO +WGRX +WGS +WGSWW +WH +WHD +WHF +WHFCL +WHG +WHLR +WHLRD +WHLRL +WHLRP +WHR +WHWK +WIA +WILC +WIMI +WINA +WING +WINN +WISE +WISH +WIT +WIW +WIX +WK +WKC +WKEY +WKHS +WKSP +WLAC +WLACU +WLACW +WLDN +WLDS +WLDSW +WLFC +WLK +WLKP +WLTG +WLY +WLYB +WM +WMB +WMG +WMK +WMS +WMT +WNC +WNEB +WNS +WNW +WOK +WOLF +WOOD +WOOF +WOR +WORK +WORX +WOW +WPC +WPM +WPP +WPRT +WRAP +WRB +WRB-E +WRB-F +WRB-G +WRB-H +WRBY +WRD +WRLD +WRND +WS +WSBC +WSBCP +WSBF +WSBK +WSC +WSFS +WSM +WSML +WSO +WSO.B +WSR +WST +WT +WTBA +WTBN +WTF +WTFC +WTFCN +WTG +WTGUR +WTGUU +WTI +WTIP +WTM +WTMU +WTMY +WTO +WTRG +WTS +WTTR +WTW +WU +WULF +WVE +WVVI +WVVIP +WW +WWD +WWW +WXM +WY +WYFI +WYHG +WYNN +XAGE +XAGEW +XAIR +XAIX +XAR +XBI +XBIL +XBIO +XBIT +XBP +XBPEW +XBTY +XCH +XCNY +XCUR +XEL +XELB +XENE +XERS +XFIX +XFLT +XFOR +XGN +XHB +XHG +XHLD +XHR +XIFR +XLB +XLE +XLF +XLI +XLK +XLO +XLP +XLRE +XLU +XLV +XLY +XMAG +XME +XMTR +XNCR +XNET +XOM +XOMA +XOMAO +XOMAP +XOMX +XOMZ +XOP +XOS +XOSWW +XOVR +XP +XPEL +XPER +XPEV +XPO +XPOF +XPON +XPRO +XRAY +XRPI +XRPT +XRTX +XRX +XT +XTIA +XTKG +XTLB +XWEL +XXII +XYF +XYL +XYZ +XYZG +YAAS +YALA +YB +YDES +YDESW +YELP +YETI +YEXT +YGMZ +YHC +YHGJ +YHNA +YHNAR +YHNAU +YI +YIBO +YJ +YLDE +YMAB +YMAT +YMM +YMT +YNOT +YOKE +YORK +YORKU +YORKW +YORW +YOU +YOUL +YPF +YQ +YQQQ +YRD +YSG +YSPY +YSXT +YTRA +YUM +YUMC +YXT +YYAI +YYGH +Z +ZAP +ZAZZT +ZBAI +ZBAO +ZBH +ZBIO +ZBRA +ZBZZT +ZCMD +ZCZZT +ZD +ZDAI +ZENA +ZENV +ZEO +ZEOWW +ZEPP +ZETA +ZEUS +ZFZZT +ZG +ZGN +ZH +ZI +ZIM +ZIMV +ZION +ZIONP +ZIP +ZIPP +ZJK +ZJYL +ZJZZT +ZK +ZKH +ZKIN +ZLAB +ZM +ZNB +ZNTL +ZOOZ +ZOOZW +ZS +ZSPC +ZTEK +ZTEN +ZTO +ZTOP +ZTR +ZTRE +ZTS +ZTWO +ZUMZ +ZURA +ZVIA +ZVRA +ZVZZT +ZWS +ZWZZT +ZXZZT +ZYBT +ZYME +ZYN +ZYXI +^AXJO +^BSESN +^BVSP +^DJI +^FCHI +^FTSE +^GDAXI +^GSPC +^GSPCTR +^HGX +^HNX +^HSI +^IXIC +^JKSE +^KLSE +^KS11 +^MXX +^N225 +^NDX +^NSEI +^NYA +^PSEI +^RUA +^RUI +^RUO +^RUT +^RUTTR +^SET +^SOX +^SP400 +^SP600 +^STI +^TNX +^TWII +^UTY +^VIX +^VNI +^XAU +^XAX +^XMI +^XOI diff --git a/scripts/data_collector/yahoo/monitor_progress.py b/scripts/data_collector/yahoo/monitor_progress.py new file mode 100644 index 0000000000..48753c387b --- /dev/null +++ b/scripts/data_collector/yahoo/monitor_progress.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python3 +""" +Monitor Yahoo Finance data collection progress +""" + +import json +import os +from pathlib import Path +import time +from datetime import datetime + +def monitor_progress(): + """Monitor collection progress""" + data_dir = Path('/workspace/qlib/data/comprehensive_yahoo_data') + progress_file = data_dir / 'collection_progress.json' + + if not data_dir.exists(): + print("❌ Data directory not found. Collection may not have started.") + return + + print("πŸ“Š YAHOO FINANCE DATA COLLECTION MONITOR") + print("=" * 60) + print(f"πŸ“ Data directory: {data_dir}") + print(f"πŸ“ Progress file: {progress_file}") + print(f"⏰ Monitor started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") + print() + + try: + while True: + # Count CSV files + csv_files = len(list(data_dir.glob('*.csv'))) + + # Read progress file if exists + if progress_file.exists(): + try: + with open(progress_file, 'r') as f: + progress = json.load(f) + + processed = progress.get('processed', 0) + total = progress.get('total', 8060) + successful = progress.get('successful', 0) + failed = progress.get('failed', 0) + empty_data = progress.get('empty_data', 0) + success_rate = progress.get('success_rate', 0) + timestamp = progress.get('timestamp', 'Unknown') + + progress_pct = (processed / total * 100) if total > 0 else 0 + + print(f"\rπŸ”„ Progress: {processed:,}/{total:,} ({progress_pct:.1f}%) | " + f"βœ… Success: {successful:,} ({success_rate:.1f}%) | " + f"❌ Failed: {failed:,} | πŸ“­ Empty: {empty_data:,} | " + f"πŸ’Ύ Files: {csv_files:,} | " + f"⏰ {timestamp[:19]}", end="", flush=True) + + except Exception as e: + print(f"\rπŸ“Š Files created: {csv_files:,} | ❌ Progress file error: {e}", end="", flush=True) + else: + print(f"\rπŸ“Š Files created: {csv_files:,} | ⚠️ No progress file yet", end="", flush=True) + + time.sleep(10) # Update every 10 seconds + + except KeyboardInterrupt: + print(f"\n\nπŸ“Š FINAL STATUS") + print(f"πŸ’Ύ Total CSV files: {csv_files:,}") + + if progress_file.exists(): + try: + with open(progress_file, 'r') as f: + final_progress = json.load(f) + print(f"βœ… Successful: {final_progress.get('successful', 0):,}") + print(f"❌ Failed: {final_progress.get('failed', 0):,}") + print(f"πŸ“­ Empty: {final_progress.get('empty_data', 0):,}") + print(f"πŸ“ˆ Success rate: {final_progress.get('success_rate', 0):.1f}%") + except: + pass + + print("\nπŸ‘‹ Monitor stopped") + +if __name__ == "__main__": + monitor_progress() \ No newline at end of file diff --git a/scripts/data_collector/yahoo/visualize_famous_stocks.py b/scripts/data_collector/yahoo/visualize_famous_stocks.py new file mode 100644 index 0000000000..1fff81ea14 --- /dev/null +++ b/scripts/data_collector/yahoo/visualize_famous_stocks.py @@ -0,0 +1,550 @@ +#!/usr/bin/env python3 +""" +Famous Stocks Visualization Script +Creates K-line (candlestick) charts and other visualizations for major stocks +""" + +import pandas as pd +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.dates as mdates +from matplotlib.patches import Rectangle +import plotly.graph_objects as go +from plotly.subplots import make_subplots +import plotly.express as px +from pathlib import Path +import warnings +from datetime import datetime, timedelta +import seaborn as sns +from typing import List, Dict, Optional + +warnings.filterwarnings('ignore') + +class StockVisualizer: + """Professional stock data visualizer with K-line charts""" + + def __init__(self, data_dir: str = '/workspace/qlib/data/comprehensive_yahoo_data', + output_dir: str = '/workspace/qlib/visualization_output'): + self.data_dir = Path(data_dir) + self.output_dir = Path(output_dir) + self.output_dir.mkdir(parents=True, exist_ok=True) + + # Famous stocks to analyze + self.famous_stocks = { + 'NVDA': 'NVIDIA Corporation', + 'TSLA': 'Tesla Inc', + 'AAPL': 'Apple Inc', + 'GOOGL': 'Alphabet Inc', + 'META': 'Meta Platforms', + 'MSFT': 'Microsoft Corporation', + 'AMZN': 'Amazon.com Inc', + 'NFLX': 'Netflix Inc', + 'AMD': 'Advanced Micro Devices', + 'CRM': 'Salesforce Inc' + } + + # Set style + plt.style.use('dark_background') + sns.set_palette("husl") + + def load_stock_data(self, symbol: str, days_back: int = 252) -> Optional[pd.DataFrame]: + """Load stock data for given symbol""" + try: + file_path = self.data_dir / f"{symbol}.csv" + if not file_path.exists(): + print(f"❌ Data not found for {symbol}") + return None + + df = pd.read_csv(file_path) + df['date'] = pd.to_datetime(df['date']) + df = df.sort_values('date').reset_index(drop=True) + + # Get recent data + if days_back: + df = df.tail(days_back) + + # Ensure we have required columns + required_cols = ['$open', '$high', '$low', '$close', '$volume'] + if not all(col in df.columns for col in required_cols): + print(f"❌ Missing required columns for {symbol}") + return None + + print(f"βœ… Loaded {len(df)} records for {symbol}") + return df + + except Exception as e: + print(f"❌ Error loading {symbol}: {e}") + return None + + def create_candlestick_chart(self, symbol: str, df: pd.DataFrame, + interactive: bool = True) -> None: + """Create candlestick (K-line) chart""" + + if interactive: + # Interactive Plotly chart + fig = make_subplots( + rows=2, cols=1, + shared_xaxes=True, + vertical_spacing=0.1, + subplot_titles=(f'{self.famous_stocks.get(symbol, symbol)} - Stock Price', 'Volume'), + row_width=[0.2, 0.7] + ) + + # Candlestick chart + fig.add_trace( + go.Candlestick( + x=df['date'], + open=df['$open'], + high=df['$high'], + low=df['$low'], + close=df['$close'], + name=symbol, + increasing_line_color='#00FF88', + decreasing_line_color='#FF3366' + ), + row=1, col=1 + ) + + # Add moving averages + df['ma_20'] = df['$close'].rolling(window=20).mean() + df['ma_50'] = df['$close'].rolling(window=50).mean() + + fig.add_trace( + go.Scatter(x=df['date'], y=df['ma_20'], + line=dict(color='orange', width=1), + name='MA20'), + row=1, col=1 + ) + + fig.add_trace( + go.Scatter(x=df['date'], y=df['ma_50'], + line=dict(color='cyan', width=1), + name='MA50'), + row=1, col=1 + ) + + # Volume chart + colors = ['green' if close >= open else 'red' + for close, open in zip(df['$close'], df['$open'])] + + fig.add_trace( + go.Bar(x=df['date'], y=df['$volume'], + marker_color=colors, name='Volume', opacity=0.7), + row=2, col=1 + ) + + # Update layout + fig.update_layout( + title=f'{symbol} - {self.famous_stocks.get(symbol, symbol)} Candlestick Chart', + template='plotly_dark', + height=800, + showlegend=True, + xaxis_rangeslider_visible=False + ) + + # Save interactive chart + output_file = self.output_dir / f'{symbol}_interactive_candlestick.html' + fig.write_html(output_file) + print(f"βœ… Saved interactive chart: {output_file}") + + else: + # Static matplotlib chart + fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(15, 10), + gridspec_kw={'height_ratios': [3, 1]}) + + # Candlestick chart + for idx, row in df.iterrows(): + color = '#00FF88' if row['$close'] >= row['$open'] else '#FF3366' + + # Candlestick body + body_height = abs(row['$close'] - row['$open']) + body_bottom = min(row['$open'], row['$close']) + + ax1.add_patch(Rectangle((idx-0.3, body_bottom), 0.6, body_height, + facecolor=color, edgecolor=color)) + + # Wicks + ax1.plot([idx, idx], [row['$low'], row['$high']], + color=color, linewidth=1) + + # Moving averages + df['ma_20'] = df['$close'].rolling(window=20).mean() + df['ma_50'] = df['$close'].rolling(window=50).mean() + + ax1.plot(df.index, df['ma_20'], color='orange', linewidth=1, label='MA20') + ax1.plot(df.index, df['ma_50'], color='cyan', linewidth=1, label='MA50') + + ax1.set_title(f'{symbol} - {self.famous_stocks.get(symbol, symbol)} Candlestick Chart', + fontsize=16, color='white') + ax1.set_ylabel('Price ($)', color='white') + ax1.legend() + ax1.grid(True, alpha=0.3) + + # Volume chart + colors = ['#00FF88' if close >= open else '#FF3366' + for close, open in zip(df['$close'], df['$open'])] + ax2.bar(df.index, df['$volume'], color=colors, alpha=0.7) + ax2.set_ylabel('Volume', color='white') + ax2.set_xlabel('Days', color='white') + + plt.tight_layout() + + # Save static chart + output_file = self.output_dir / f'{symbol}_candlestick.png' + plt.savefig(output_file, dpi=300, bbox_inches='tight', + facecolor='black', edgecolor='none') + plt.close() + print(f"βœ… Saved static chart: {output_file}") + + def create_comparison_chart(self, symbols: List[str], days_back: int = 252) -> None: + """Create comparison chart for multiple stocks""" + + stock_data = {} + for symbol in symbols: + df = self.load_stock_data(symbol, days_back) + if df is not None: + # Normalize to percentage change from start + start_price = df['$close'].iloc[0] + df['normalized'] = (df['$close'] / start_price - 1) * 100 + stock_data[symbol] = df + + if not stock_data: + print("❌ No data available for comparison") + return + + # Interactive comparison + fig = go.Figure() + + for symbol, df in stock_data.items(): + fig.add_trace( + go.Scatter( + x=df['date'], + y=df['normalized'], + mode='lines', + name=f'{symbol} - {self.famous_stocks.get(symbol, symbol)}', + line=dict(width=2) + ) + ) + + fig.update_layout( + title='Famous Stocks Performance Comparison (Normalized)', + template='plotly_dark', + height=600, + xaxis_title='Date', + yaxis_title='Performance (%)', + showlegend=True + ) + + # Save comparison chart + output_file = self.output_dir / 'famous_stocks_comparison.html' + fig.write_html(output_file) + print(f"βœ… Saved comparison chart: {output_file}") + + # Static version + plt.figure(figsize=(15, 8)) + for symbol, df in stock_data.items(): + plt.plot(df.index, df['normalized'], linewidth=2, + label=f'{symbol} - {self.famous_stocks.get(symbol, symbol)}') + + plt.title('Famous Stocks Performance Comparison (Normalized)', + fontsize=16, color='white') + plt.xlabel('Days', color='white') + plt.ylabel('Performance (%)', color='white') + plt.legend() + plt.grid(True, alpha=0.3) + plt.tight_layout() + + output_file = self.output_dir / 'famous_stocks_comparison.png' + plt.savefig(output_file, dpi=300, bbox_inches='tight', + facecolor='black', edgecolor='none') + plt.close() + print(f"βœ… Saved static comparison: {output_file}") + + def create_volatility_analysis(self, symbols: List[str], days_back: int = 252) -> None: + """Create volatility analysis for stocks""" + + volatility_data = [] + + for symbol in symbols: + df = self.load_stock_data(symbol, days_back) + if df is not None: + # Calculate returns and volatility + df['returns'] = df['$close'].pct_change() + volatility = df['returns'].std() * np.sqrt(252) * 100 # Annualized + avg_return = df['returns'].mean() * 252 * 100 # Annualized + + volatility_data.append({ + 'Symbol': symbol, + 'Name': self.famous_stocks.get(symbol, symbol), + 'Volatility (%)': volatility, + 'Average Return (%)': avg_return + }) + + if not volatility_data: + print("❌ No data for volatility analysis") + return + + vol_df = pd.DataFrame(volatility_data) + + # Risk-Return scatter plot + fig = px.scatter( + vol_df, + x='Volatility (%)', + y='Average Return (%)', + text='Symbol', + title='Risk-Return Analysis (Annualized)', + template='plotly_dark', + height=600 + ) + + fig.update_traces(textposition="top center", marker_size=10) + fig.update_layout(showlegend=False) + + # Save risk-return chart + output_file = self.output_dir / 'risk_return_analysis.html' + fig.write_html(output_file) + print(f"βœ… Saved risk-return analysis: {output_file}") + + # Print results + print(f"\nπŸ“Š Risk-Return Analysis:") + print(vol_df.round(2).to_string(index=False)) + + def create_technical_analysis(self, symbol: str, df: pd.DataFrame) -> None: + """Create technical analysis with indicators""" + + # Calculate technical indicators + df = df.copy() + + # Moving averages + df['ma_20'] = df['$close'].rolling(window=20).mean() + df['ma_50'] = df['$close'].rolling(window=50).mean() + + # Bollinger Bands + df['bb_middle'] = df['$close'].rolling(window=20).mean() + bb_std = df['$close'].rolling(window=20).std() + df['bb_upper'] = df['bb_middle'] + (bb_std * 2) + df['bb_lower'] = df['bb_middle'] - (bb_std * 2) + + # RSI + delta = df['$close'].diff() + gain = (delta.where(delta > 0, 0)).rolling(window=14).mean() + loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean() + rs = gain / loss + df['rsi'] = 100 - (100 / (1 + rs)) + + # MACD + exp1 = df['$close'].ewm(span=12).mean() + exp2 = df['$close'].ewm(span=26).mean() + df['macd'] = exp1 - exp2 + df['macd_signal'] = df['macd'].ewm(span=9).mean() + df['macd_histogram'] = df['macd'] - df['macd_signal'] + + # Create subplots + fig = make_subplots( + rows=4, cols=1, + shared_xaxes=True, + vertical_spacing=0.05, + subplot_titles=[ + f'{symbol} - Price & Bollinger Bands', + 'Volume', + 'RSI', + 'MACD' + ], + row_heights=[0.5, 0.15, 0.15, 0.2] + ) + + # Price chart with Bollinger Bands + fig.add_trace( + go.Candlestick( + x=df['date'], + open=df['$open'], + high=df['$high'], + low=df['$low'], + close=df['$close'], + name='Price' + ), + row=1, col=1 + ) + + # Bollinger Bands + fig.add_trace( + go.Scatter(x=df['date'], y=df['bb_upper'], + line=dict(color='gray', width=1), name='BB Upper'), + row=1, col=1 + ) + fig.add_trace( + go.Scatter(x=df['date'], y=df['bb_lower'], + line=dict(color='gray', width=1), name='BB Lower', + fill='tonexty', fillcolor='rgba(128,128,128,0.1)'), + row=1, col=1 + ) + + # Moving averages + fig.add_trace( + go.Scatter(x=df['date'], y=df['ma_20'], + line=dict(color='orange', width=1), name='MA20'), + row=1, col=1 + ) + fig.add_trace( + go.Scatter(x=df['date'], y=df['ma_50'], + line=dict(color='cyan', width=1), name='MA50'), + row=1, col=1 + ) + + # Volume + colors = ['green' if close >= open else 'red' + for close, open in zip(df['$close'], df['$open'])] + fig.add_trace( + go.Bar(x=df['date'], y=df['$volume'], + marker_color=colors, name='Volume', opacity=0.7), + row=2, col=1 + ) + + # RSI + fig.add_trace( + go.Scatter(x=df['date'], y=df['rsi'], + line=dict(color='purple', width=2), name='RSI'), + row=3, col=1 + ) + fig.add_hline(y=70, line_dash="dash", line_color="red", row=3, col=1) + fig.add_hline(y=30, line_dash="dash", line_color="green", row=3, col=1) + + # MACD + fig.add_trace( + go.Scatter(x=df['date'], y=df['macd'], + line=dict(color='blue', width=2), name='MACD'), + row=4, col=1 + ) + fig.add_trace( + go.Scatter(x=df['date'], y=df['macd_signal'], + line=dict(color='red', width=2), name='Signal'), + row=4, col=1 + ) + fig.add_trace( + go.Bar(x=df['date'], y=df['macd_histogram'], + marker_color='gray', name='Histogram', opacity=0.6), + row=4, col=1 + ) + + # Update layout + fig.update_layout( + title=f'{symbol} - {self.famous_stocks.get(symbol, symbol)} Technical Analysis', + template='plotly_dark', + height=1000, + showlegend=True, + xaxis_rangeslider_visible=False + ) + + # Save technical analysis + output_file = self.output_dir / f'{symbol}_technical_analysis.html' + fig.write_html(output_file) + print(f"βœ… Saved technical analysis: {output_file}") + + def generate_summary_report(self, symbols: List[str]) -> None: + """Generate comprehensive summary report""" + + report_data = [] + + for symbol in symbols: + df = self.load_stock_data(symbol, 252) # 1 year of data + if df is not None: + # Calculate key metrics + current_price = df['$close'].iloc[-1] + price_52w_high = df['$high'].max() + price_52w_low = df['$low'].min() + + returns = df['$close'].pct_change() + ytd_return = (df['$close'].iloc[-1] / df['$close'].iloc[0] - 1) * 100 + volatility = returns.std() * np.sqrt(252) * 100 + avg_volume = df['$volume'].mean() + + # Recent performance + recent_30d = df.tail(30) + monthly_return = (recent_30d['$close'].iloc[-1] / recent_30d['$close'].iloc[0] - 1) * 100 + + report_data.append({ + 'Symbol': symbol, + 'Name': self.famous_stocks.get(symbol, symbol)[:20], + 'Current Price': f"${current_price:.2f}", + '52W High': f"${price_52w_high:.2f}", + '52W Low': f"${price_52w_low:.2f}", + 'YTD Return (%)': f"{ytd_return:.1f}", + '30D Return (%)': f"{monthly_return:.1f}", + 'Volatility (%)': f"{volatility:.1f}", + 'Avg Volume': f"{avg_volume/1000000:.1f}M" + }) + + if report_data: + report_df = pd.DataFrame(report_data) + + # Save to CSV + csv_file = self.output_dir / 'famous_stocks_summary.csv' + report_df.to_csv(csv_file, index=False) + + print(f"\nπŸ“Š FAMOUS STOCKS SUMMARY REPORT") + print("=" * 80) + print(report_df.to_string(index=False)) + print(f"\nβœ… Summary saved to: {csv_file}") + + def create_all_visualizations(self, days_back: int = 252) -> None: + """Create all visualizations for famous stocks""" + + print("πŸš€ CREATING COMPREHENSIVE STOCK VISUALIZATIONS") + print("=" * 60) + print(f"πŸ“ Output directory: {self.output_dir}") + print(f"πŸ“… Using last {days_back} days of data") + print() + + available_stocks = [] + + # Create individual charts for each stock + for symbol in self.famous_stocks.keys(): + print(f"πŸ“ˆ Processing {symbol} - {self.famous_stocks[symbol]}...") + + df = self.load_stock_data(symbol, days_back) + if df is not None: + available_stocks.append(symbol) + + # Create candlestick charts + self.create_candlestick_chart(symbol, df, interactive=True) + self.create_candlestick_chart(symbol, df, interactive=False) + + # Create technical analysis + self.create_technical_analysis(symbol, df) + + print(f" βœ… Completed visualizations for {symbol}") + else: + print(f" ❌ Skipped {symbol} (no data)") + + print() + + # Create comparison charts + if len(available_stocks) >= 2: + print("πŸ“Š Creating comparison and analysis charts...") + self.create_comparison_chart(available_stocks, days_back) + self.create_volatility_analysis(available_stocks, days_back) + self.generate_summary_report(available_stocks) + + print(f"\nπŸŽ‰ VISUALIZATION COMPLETE!") + print(f"βœ… Processed {len(available_stocks)} stocks") + print(f"πŸ“ All charts saved to: {self.output_dir}") + print(f"🌐 Open the .html files in your browser for interactive charts") + + +def main(): + """Main execution function""" + + # Create visualizer + visualizer = StockVisualizer() + + # Generate all visualizations + visualizer.create_all_visualizations(days_back=252) # 1 year of data + + print(f"\nπŸ“ Generated files:") + output_files = list(visualizer.output_dir.glob('*')) + for file in sorted(output_files): + print(f" πŸ“„ {file.name}") + + +if __name__ == "__main__": + main() \ No newline at end of file