Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,16 @@
+OAI_CONFIG_LIST
+config_api_keys
+__pycache__/
+.ipynb_checkpoints/
+.cache/
+*.csv
+*.jpg
+*.png
+quant/
+coding/
+*.egg-info/
+.DS_Store
+projects/
+dist/
+tmp/
+*.env

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "FinNLP"]
+	path = FinNLP
+	url = https://github.com/AI4Finance-Foundation/FinNLP.git

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python.analysis.extraPaths": [
+        "./FinNLP"
+    ]
+}

LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 AI4Finance Foundation Inc.
+   All rights reserved.
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

OAI_CONFIG_LIST_sample

@@ -0,0 +1,28 @@
+// Please modify the content, remove these four lines of comment and rename this file to OAI_CONFIG_LIST to run the sample code.
+// If using pyautogen v0.1.x with Azure OpenAI, please replace "base_url" with "api_base" (line 13 and line 20 below). Use "pip list" to check version of pyautogen installed.
+//
+// NOTE: This configuration lists GPT-4 as the default model, as this represents our current recommendation, and is known to work well with AutoGen. If you use a model other than GPT-4, you may need to revise various system prompts (especially if using weaker models like GPT-3.5-turbo). Moreover, if you use models other than those hosted by OpenAI or Azure, you may incur additional risks related to alignment and safety. Proceed with caution if updating this default.
+[
+    {
+        "model": "gpt-4-0125-preview",
+        "api_key": "<your OpenAI API key here>"
+    },
+    {
+        "model": "gpt-4-1106-vision-preview",
+        "api_key": "<your OpenAI API key here>"
+    },
+    {
+        "model": "<your Azure OpenAI deployment name>",
+        "api_key": "<your Azure OpenAI API key here>",
+        "base_url": "<your Azure OpenAI API base here>",
+        "api_type": "azure",
+        "api_version": "2024-02-15-preview"
+    },
+    {
+        "model": "<your Azure OpenAI deployment name>",
+        "api_key": "<your Azure OpenAI API key here>",
+        "base_url": "<your Azure OpenAI API base here>",
+        "api_type": "azure",
+        "api_version": "2024-02-15-preview"
+    }
+]

Procfile

@@ -0,0 +1 @@
+web: python servercn.py

README.md

@@ -1,12 +1,313 @@
 ---
-title: Finaich
-emoji: 💻
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 4.36.1
+title: finaich
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 4.31.5
 ---
+<div align="center">
+<img align="center" width="30%" alt="image" src="https://github.com/AI4Finance-Foundation/FinGPT/assets/31713746/e0371951-1ce1-488e-aa25-0992dafcc139">
+</div>
+
+# FinRobot: An Open-Source AI Agent Platform for Financial Applications using Large Language Models
+[![Downloads](https://static.pepy.tech/badge/finrobot)]([https://pepy.tech/project/finrobot](https://pepy.tech/project/finrobot))
+[![Downloads](https://static.pepy.tech/badge/finrobot/week)](https://pepy.tech/project/finrobot)
+[![Python 3.8](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/)
+[![PyPI](https://img.shields.io/pypi/v/finrobot.svg)](https://pypi.org/project/finrobot/)
+![License](https://img.shields.io/github/license/AI4Finance-Foundation/finrobot.svg?color=brightgreen)
+
+<div align="center">
+<img align="center" src=figs/logo_white_background.jpg width="40%"/>
+</div>
+
+**FinRobot** is an AI Agent Platform that transcends the scope of FinGPT, representing a comprehensive solution meticulously designed for financial applications. It integrates **a diverse array of AI technologies**, extending beyond mere language models. This expansive vision highlights the platform's versatility and adaptability, addressing the multifaceted needs of the financial industry.
+
+**Concept of AI Agent**: an AI Agent is an intelligent entity that uses large language models as its brain to perceive its environment, make decisions, and execute actions. Unlike traditional artificial intelligence, AI Agents possess the ability to independently think and utilize tools to progressively achieve given objectives.
+
+[Whitepaper of FinRobot](https://arxiv.org/abs/2405.14767)
+
+[![](https://dcbadge.vercel.app/api/server/trsr8SXpW5)](https://discord.gg/trsr8SXpW5)
+
+## FinRobot Ecosystem
+<div align="center">
+<img align="center" src="https://github.com/AI4Finance-Foundation/FinRobot/assets/31713746/6b30d9c1-35e5-4d36-a138-7e2769718f62" width="90%"/>
+</div>
+
+### The overall framework of FinRobot is organized into four distinct layers, each designed to address specific aspects of financial AI processing and application:
+1. **Financial AI Agents Layer**: The Financial AI Agents Layer now includes Financial Chain-of-Thought (CoT) prompting, enhancing complex analysis and decision-making capacity. Market Forecasting Agents, Document Analysis Agents, and Trading Strategies Agents utilize CoT to dissect financial challenges into logical steps, aligning their advanced algorithms and domain expertise with the evolving dynamics of financial markets for precise, actionable insights.
+2. **Financial LLMs Algorithms Layer**: The Financial LLMs Algorithms Layer configures and utilizes specially tuned models tailored to specific domains and global market analysis. 
+3. **LLMOps and DataOps Layers**: The LLMOps layer implements a multi-source integration strategy that selects the most suitable LLMs for specific financial tasks, utilizing a range of state-of-the-art models. 
+4. **Multi-source LLM Foundation Models Layer**: This foundational layer supports the plug-and-play functionality of various general and specialized LLMs. 
+
+
+## FinRobot: Agent Workflow
+<div align="center">
+<img align="center" src="https://github.com/AI4Finance-Foundation/FinRobot/assets/31713746/ff8033be-2326-424a-ac11-17e2c9c4983d" width="60%"/>
+</div>
+
+1. **Perception**: This module captures and interprets multimodal financial data from market feeds, news, and economic indicators, using sophisticated techniques to structure the data for thorough analysis.
+
+2. **Brain**: Acting as the core processing unit, this module perceives data from the Perception module with LLMs and utilizes Financial Chain-of-Thought (CoT) processes to generate structured instructions.
+
+3. **Action**: This module executes instructions from the Brain module, applying tools to translate analytical insights into actionable outcomes. Actions include trading, portfolio adjustments, generating reports, or sending alerts, thereby actively influencing the financial environment.
+
+## FinRobot: Smart Scheduler
+<div align="center">
+<img align="center" src="https://github.com/AI4Finance-Foundation/FinRobot/assets/31713746/06fa0b78-ac53-48d3-8a6e-98d15386327e" width="60%"/>
+</div>
+
+The Smart Scheduler is central to ensuring model diversity and optimizing the integration and selection of the most appropriate LLM for each task.
+* **Director Agent**: This component orchestrates the task assignment process, ensuring that tasks are allocated to agents based on their performance metrics and suitability for specific tasks.
+* **Agent Registration**: Manages the registration and tracks the availability of agents within the system, facilitating an efficient task allocation process.
+* **Agent Adaptor**: Tailor agent functionalities to specific tasks, enhancing their performance and integration within the overall system.
+* **Task Manager**: Manages and stores different general and fine-tuned LLMs-based agents tailored for various financial tasks, updated periodically to ensure relevance and efficacy.
+
+## File Structure
+
+The main folder **finrobot** has three subfolders **agents, data_source, functional**. 
+
+```
+FinRobot
+├── finrobot (main folder)
+│   ├── agents
+│   	├── agent_library.py
+│   	└── workflow.py
+│   ├── data_source
+│   	├── finnhub_utils.py
+│   	├── finnlp_utils.py
+│   	├── fmp_utils.py
+│   	├── sec_utils.py
+│   	└── yfinance_utils.py
+│   ├── functional
+│   	├── analyzer.py
+│   	├── charting.py
+│   	├── coding.py
+│   	├── quantitative.py
+│   	├── reportlab.py
+│   	└── text.py
+│   ├── toolkits.py
+│   └── utils.py
+│
+├── configs
+├── experiments
+├── tutorials_beginner (hands-on tutorial)
+│   ├── agent_fingpt_forecaster.ipynb
+│   └── agent_annual_report.ipynb 
+├── tutorials_advanced (advanced tutorials for potential finrobot developers)
+│   ├── agent_trade_strategist.ipynb
+│   ├── agent_fingpt_forecaster.ipynb
+│   ├── agent_annual_report.ipynb 
+│   ├── lmm_agent_mplfinance.ipynb
+│   └── lmm_agent_opt_smacross.ipynb
+├── setup.py
+├── OAI_CONFIG_LIST_sample
+├── config_api_keys_sample
+├── requirements.txt
+└── README.md
+```
+
+## Installation:
+
+**1. (Recommended) Create a new virtual environment**
+```shell
+conda create --name finrobot python=3.10
+conda activate finrobot
+```
+**2. download the FinRobot repo use terminal or download it manually**
+```shell
+git clone https://github.com/AI4Finance-Foundation/FinRobot.git
+cd FinRobot
+```
+**3. install finrobot & dependencies from source or pypi**
+
+get our latest release from pypi
+```bash
+pip install -U finrobot
+```
+or install from this repo directly
+```
+pip install -e .
+```
+**4. modify OAI_CONFIG_LIST_sample file**
+```shell
+1) rename OAI_CONFIG_LIST_sample to OAI_CONFIG_LIST
+2) remove the four lines of comment within the OAI_CONFIG_LIST file
+3) add your own openai api-key <your OpenAI API key here>
+```
+**5. modify config_api_keys_sample file**
+```shell
+1) rename config_api_keys_sample to config_api_keys
+2) remove the comment within the config_api_keys file
+3) add your own finnhub-api "YOUR_FINNHUB_API_KEY"
+4) add your own financialmodelingprep and sec-api keys "YOUR_FMP_API_KEY" and "YOUR_SEC_API_KEY" (for financial report generation)
+```
+**6. start navigating the tutorials or the demos below:**
+```
+# find these notebooks in tutorials
+1) agent_annual_report.ipynb
+2) agent_fingpt_forecaster.ipynb
+3) agent_trade_strategist.ipynb
+4) lmm_agent_mplfinance.ipynb
+5) lmm_agent_opt_smacross.ipynb
+```
+
+## Demos
+### 1. Market Forecaster Agent (Predict Stock Movements Direction)
+Takes a company's ticker symbol, recent basic financials, and market news as input and predicts its stock movements.
+
+1. Import 
+```python
+import autogen
+from finrobot.utils import get_current_date, register_keys_from_json
+from finrobot.agents.workflow import SingleAssistant
+```
+2. Config
+```python
+# Read OpenAI API keys from a JSON file
+llm_config = {
+    "config_list": autogen.config_list_from_json(
+        "../OAI_CONFIG_LIST",
+        filter_dict={"model": ["gpt-4-0125-preview"]},
+    ),
+    "timeout": 120,
+    "temperature": 0,
+}
+
+# Register FINNHUB API keys
+register_keys_from_json("../config_api_keys")
+```
+3. Run
+```python
+company = "NVDA"
+
+assitant = SingleAssistant(
+    "Market_Analyst",
+    llm_config,
+    # set to "ALWAYS" if you want to chat instead of simply receiving the prediciton
+    human_input_mode="NEVER",
+)
+assitant.chat(
+    f"Use all the tools provided to retrieve information available for {company} upon {get_current_date()}. Analyze the positive developments and potential concerns of {company} "
+    "with 2-4 most important factors respectively and keep them concise. Most factors should be inferred from company related news. "
+    f"Then make a rough prediction (e.g. up/down by 2-3%) of the {company} stock price movement for next week. Provide a summary analysis to support your prediction."
+)
+```
+4. Result
+<div align="center">
+<img align="center" src="https://github.com/AI4Finance-Foundation/FinRobot/assets/31713746/812ec23a-9cb3-4fad-b716-78533ddcd9dc" width="40%"/>
+<img align="center" src="https://github.com/AI4Finance-Foundation/FinRobot/assets/31713746/9a2f9f48-b0e1-489c-8679-9a4c530f313c" width="41%"/>
+</div>
+
+### 2. Financial Analyst Agent for Report Writing (Equity Research Report)
+Take a company's 10-k form, financial data, and market data as input and output an equity research report
+
+1. Import 
+```python
+import os
+import autogen
+from textwrap import dedent
+from finrobot.utils import register_keys_from_json
+from finrobot.agents.workflow import SingleAssistantShadow
+```
+2. Config
+```python
+llm_config = {
+    "config_list": autogen.config_list_from_json(
+        "../OAI_CONFIG_LIST",
+        filter_dict={
+            "model": ["gpt-4-0125-preview"],
+        },
+    ),
+    "timeout": 120,
+    "temperature": 0.5,
+}
+register_keys_from_json("../config_api_keys")
+
+# Intermediate strategy modules will be saved in this directory
+work_dir = "../report"
+os.makedirs(work_dir, exist_ok=True)
+
+assistant = SingleAssistantShadow(
+    "Expert_Investor",
+    llm_config,
+    max_consecutive_auto_reply=None,
+    human_input_mode="TERMINATE",
+)
+
+```
+3. Run
+```python
+company = "Microsoft"
+fyear = "2023"
+
+message = dedent(
+    f"""
+    With the tools you've been provided, write an annual report based on {company}'s {fyear} 10-k report, format it into a pdf.
+    Pay attention to the followings:
+    - Explicitly explain your working plan before you kick off.
+    - Use tools one by one for clarity, especially when asking for instructions. 
+    - All your file operations should be done in "{work_dir}". 
+    - Display any image in the chat once generated.
+    - All the paragraphs should combine between 400 and 450 words, don't generate the pdf until this is explicitly fulfilled.
+"""
+)
+
+assistant.chat(message, use_cache=True, max_turns=50,
+               summary_method="last_msg")
+```
+4. Result
+<div align="center">
+<img align="center" src="https://github.com/AI4Finance-Foundation/FinRobot/assets/31713746/d2d999e0-dc0e-4196-aca1-218f5fadcc5b" width="60%"/>
+<img align="center" src="https://github.com/AI4Finance-Foundation/FinRobot/assets/31713746/3a21873f-9498-4d73-896b-3740bf6d116d" width="60%"/>
+</div>
+
+**Financial CoT**:
+1. **Gather Preliminary Data**: 10-K report, market data, financial ratios
+2. **Analyze Financial Statements**: balance sheet, income statement, cash flow
+3. **Company Overview and Performance**: company description, business highlights, segment analysis
+4. **Risk Assessment**: assess risks
+5. **Financial Performance Visualization**:  plot PE ratio and EPS
+6. **Synthesize Findings into Paragraphs**: combine all parts into a coherent summary
+7. **Generate PDF Report**: use tools to generate PDF automatically
+8. **Quality Assurance**: check word counts
+
+### 3. Trade Strategist Agent with multimodal capabilities
+
+
+## AI Agent Papers
+
++ [Stanford University + Microsoft Research] [Agent AI: Surveying the Horizons of Multimodal Interaction](https://arxiv.org/abs/2401.03568)
++ [Stanford University] [Generative Agents: Interactive Simulacra of Human Behavior](https://arxiv.org/abs/2304.03442)
++ [Fudan NLP Group] [The Rise and Potential of Large Language Model Based Agents: A Survey](https://arxiv.org/abs/2309.07864)
++ [Fudan NLP Group] [LLM-Agent-Paper-List](https://github.com/WooooDyy/LLM-Agent-Paper-List)
++ [Tsinghua University] [Large Language Models Empowered Agent-based Modeling and Simulation: A Survey and Perspectives](https://arxiv.org/abs/2312.11970)
++ [Renmin University] [A Survey on Large Language Model-based Autonomous Agents](https://arxiv.org/pdf/2308.11432.pdf)
++ [Nanyang Technological University] [FinAgent: A Multimodal Foundation Agent for Financial Trading: Tool-Augmented, Diversified, and Generalist](https://arxiv.org/abs/2402.18485)
+
+## AI Agent Blogs and Videos
++ [Medium] [An Introduction to AI Agents](https://medium.com/humansdotai/an-introduction-to-ai-agents-e8c4afd2ee8f)
++ [Medium] [Unmasking the Best Character AI Chatbots | 2024](https://medium.com/@aitrendorbit/unmasking-the-best-character-ai-chatbots-2024-351de43792f4#the-best-character-ai-chatbots)
++ [big-picture] [ChatGPT, Next Level: Meet 10 Autonomous AI Agents](https://blog.big-picture.com/en/chatgpt-next-level-meet-10-autonomous-ai-agents-auto-gpt-babyagi-agentgpt-microsoft-jarvis-chaosgpt-friends/)
++ [TowardsDataScience] [Navigating the World of LLM Agents: A Beginner’s Guide](https://towardsdatascience.com/navigating-the-world-of-llm-agents-a-beginners-guide-3b8d499db7a9)
++ [YouTube] [Introducing Devin - The "First" AI Agent Software Engineer](https://www.youtube.com/watch?v=iVbN95ica_k)
+
+
+## AI Agent Open-Source Framework & Tool
++ [AutoGPT (161k stars)](https://github.com/Significant-Gravitas/AutoGPT) is a tool for everyone to use, aiming to democratize AI, making it accessible for everyone to use and build upon.
++ [LangChain (82.7k stars)](https://github.com/langchain-ai/langchain) is a framework for developing context-aware applications powered by language models, enabling them to connect to sources of context and rely on the model's reasoning capabilities for responses and actions.
++ [MetaGPT (39.1k stars)](https://github.com/geekan/MetaGPT) is a multi-agent open-source framework that assigns different roles to GPTs, forming a collaborative software entity to execute complex tasks.
++ [AutoGen (24.8k stars)](https://github.com/microsoft/autogen) is a framework for developing LLM applications with conversational agents that collaborate to solve tasks. These agents are customizable, support human interaction, and operate in modes combining LLMs, human inputs, and tools.
++ [dify (22.7k stars)](https://github.com/langgenius/dify) is an LLM application development platform. It integrates the concepts of Backend as a Service and LLMOps, covering the core tech stack required for building generative AI-native applications, including a built-in RAG engine
++ [ChatDev (22.7k stars)](https://github.com/OpenBMB/ChatDev) is a framework that focuses on developing conversational AI Agents capable of dialogue and question-answering. It provides a range of pre-trained models and interactive interfaces, facilitating the development of customized chat Agents for users.
++ [BabyAGI (19.2k stars)](https://github.com/yoheinakajima/babyagi) is an AI-powered task management system, dedicated to building AI Agents with preliminary general intelligence. 
++ [SuperAGI (14.4k stars)](https://github.com/TransformerOptimus/SuperAGI) is a dev-first open-source autonomous AI agent framework enabling developers to build, manage & run useful autonomous agents.
++ [FastGPT (12.5k stars)](https://github.com/labring/FastGPT) is a knowledge-based platform built on the LLM, offers out-of-the-box data processing and model invocation capabilities, allows for workflow orchestration through Flow visualization.
++ [CrewAI (12.1k stars)](https://github.com/joaomdmoura/crewAI) is a framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
++ [XAgent (7.5k stars)](https://github.com/OpenBMB/XAgent) is an open-source experimental Large Language Model (LLM) driven autonomous agent that can automatically solve various tasks.
++ [Bisheng (5.5k stars)](https://github.com/dataelement/bisheng) is a leading open-source platform for developing LLM applications.
++ [Voyager (5.1k stars)](https://github.com/OpenBMB/XAgent) An Open-Ended Embodied Agent with Large Language Models.
++ [CAMEL (4.4k stars)](https://github.com/camel-ai/camel) is a framework that offers a comprehensive set of tools and algorithms for building multimodal AI Agents, enabling them to handle various data forms such as text, images, and speech.
++ [Langfuse (2.9k stars)](https://github.com/langfuse/langfuse) is a language fusion framework that can integrate the language abilities of multiple AI Agents, enabling them to simultaneously possess multilingual understanding and generation capabilities.
+
+**Disclaimer**: The codes and documents provided herein are released under the Apache-2.0 license. They should not be construed as financial counsel or recommendations for live trading. It is imperative to exercise caution and consult with qualified financial professionals prior to any trading or investment actions.
+
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agent_builder_demo.py

@@ -0,0 +1,44 @@
+import os
+import autogen
+from autogen.agentchat.contrib.agent_builder import AgentBuilder
+from finrobot.utils import get_current_date
+
+
+config_file_or_env = "OAI_CONFIG_LIST"
+llm_config = {"temperature": 0}
+
+builder = AgentBuilder(
+    config_file_or_env=config_file_or_env,
+    builder_model="gpt-4-0125-preview",
+    agent_model="gpt-4-0125-preview",
+)
+
+config_list = autogen.config_list_from_json(
+    config_file_or_env, filter_dict={"model": ["gpt-4-0125-preview"]}
+)
+
+building_task = "Gather information like company profile, recent stock price fluctuations, market news, and financial basics of a specified company (e.g. AAPL) by programming and analyze its current positive developments and potential concerns. Based on all the information, come up with a rough estimate (e.g. up by 2-3%) and give a summary of the reasons for next week's stock price. Each python program should execute on its own, and avoid plotting any chart."
+config_path = "configs/save_config_forecaster.json"
+
+if os.path.exists(config_path):
+    agent_list, agent_config = builder.load(config_path)
+else:
+    agent_list, agent_configs = builder.build(
+        building_task,
+        llm_config,
+        coding=True,
+        code_execution_config={
+            "work_dir": "coding",
+            "use_docker": False,
+        },
+    )
+    builder.save(config_path)
+
+group_chat = autogen.GroupChat(agents=agent_list, messages=[], max_round=20)
+manager = autogen.GroupChatManager(
+    groupchat=group_chat, llm_config={"config_list": config_list, **llm_config}
+)
+agent_list[0].initiate_chat(
+    manager,
+    message=f"Today is {get_current_date()}, predict next week's stock price for Nvidia with its recent market news and stock price movements.",
+)

app.py

@@ -0,0 +1,199 @@
+import os
+import json
+import pandas as pd
+from datetime import date
+import gradio as gr
+import autogen
+from autogen.cache import Cache
+from finrobot.utils import get_current_date
+from finrobot.data_source import FinnHubUtils, YFinanceUtils
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Utility functions
+def save_output(data: pd.DataFrame, tag: str, save_path: str = None) -> None:
+    if save_path:
+        data.to_csv(save_path)
+        print(f"{tag} saved to {save_path}")
+
+def get_current_date():
+    return date.today().strftime("%Y-%m-%d")
+
+def register_keys():
+    keys = {
+        "FINNHUB_API_KEY": os.getenv("FINNHUB_API_KEY"),
+        "FMP_API_KEY": os.getenv("FMP_API_KEY"),
+        "SEC_API_KEY": os.getenv("SEC_API_KEY")
+    }
+    for key, value in keys.items():
+        if value:
+            os.environ[key] = value
+
+def read_response_from_md(filename):
+    with open(filename, "r") as file:
+        content = file.read()
+    return content
+
+def save_to_md(content, filename):
+    with open(filename, "w") as file:  # Use write mode to overwrite the file
+        file.write(content + "\n")
+    print(f"Content saved to {filename}")
+
+# Initialize LLM configuration
+config_list = [
+    {
+        "model": "gpt-4o",
+        "api_key": os.getenv("OPENAI_API_KEY")
+    }
+]
+llm_config = {"config_list": config_list, "timeout": 120, "temperature": 0}
+
+# Register FINNHUB API keys
+register_keys()
+
+# Define agents
+analyst = autogen.AssistantAgent(
+    name="Market_Analyst",
+    system_message="As a Market Analyst, one must possess strong analytical and problem-solving abilities, collect necessary financial information and aggregate them based on client's requirement. For coding tasks, only use the functions you have been provided with. Reply TERMINATE when the task is done.",
+    llm_config=llm_config,
+)
+
+user_proxy = autogen.UserProxyAgent(
+    name="User_Proxy",
+    is_termination_msg=lambda x: x.get("content", "") and x.get("content", "").strip().endswith("TERMINATE"),
+    human_input_mode="NEVER",
+    max_consecutive_auto_reply=10,
+    code_execution_config={
+        "work_dir": "coding",
+        "use_docker": False,
+    },
+)
+
+# Register tools
+from finrobot.toolkits import register_toolkits
+
+tools = [
+    {
+        "function": FinnHubUtils.get_company_profile,
+        "name": "get_company_profile",
+        "description": "get a company's profile information"
+    },
+    {
+        "function": FinnHubUtils.get_company_news,
+        "name": "get_company_news",
+        "description": "retrieve market news related to designated company"
+    },
+    {
+        "function": FinnHubUtils.get_basic_financials,
+        "name": "get_financial_basics",
+        "description": "get latest financial basics for a designated company"
+    },
+    {
+        "function": YFinanceUtils.get_stock_data,
+        "name": "get_stock_data",
+        "description": "retrieve stock price data for designated ticker symbol"
+    }
+]
+register_toolkits(tools, analyst, user_proxy)
+
+def save_response_to_json(response, filename):
+    response_dict = {
+        "chat_id": response.chat_id,
+        "chat_history": response.chat_history,
+        "summary": response.summary,
+        "cost": response.cost,
+        "human_input": response.human_input
+    }
+    with open(filename, "w") as file:
+        file.write(json.dumps(response_dict, indent=4))
+    print(f"Response saved to {filename}")
+
+# Function to initiate chat and save response
+def initiate_chat_and_save_response(analyst, user_proxy, company):
+    today_date = get_current_date()
+    json_filename = f"result_{company}_{today_date}.json"
+    md_filename = f"result_{company}_{today_date}.md"
+    
+    # Check if MD file already exists
+    if os.path.exists(md_filename):
+        return read_response_from_md(md_filename)
+    
+    with Cache.disk() as cache:
+        response = user_proxy.initiate_chat(
+            analyst,
+            message=f"Report in Chinese. Use all the tools provided to retrieve information available for {company} upon {get_current_date()}. Analyze the positive developments and potential concerns of {company} with 2-4 most important factors respectively and keep them concise. Most factors should be inferred from company related news. Then make a rough prediction (e.g. up/down by %) of the {company} stock price movement for next week. Provide a summary analysis to support your prediction.",
+            cache=cache,
+        )
+        
+        save_response_to_json(response, json_filename)
+        return json.dumps(response.chat_history, indent=4)
+
+def filter_user_content(chat_history):
+    # 解析 chat_history 为 JSON 对象
+    chat_history_dict = json.loads(chat_history)
+    # 查找用户需要的内容
+    for entry in chat_history_dict:
+        if entry['role'] == 'user' and "###" in entry['content']:
+            return entry['content']
+    return "No relevant content found."
+
+# 使用更新的函数在 analyze_company 中
+def analyze_company(company):
+    if company:
+        company = company.upper()
+        today_date = get_current_date()
+        md_filename = f"result_{company}_{today_date}.md"
+        
+        # Check if MD file already exists
+        if os.path.exists(md_filename):
+            return read_response_from_md(md_filename)
+        
+        content = initiate_chat_and_save_response(analyst, user_proxy, company)
+        # 筛选有效的用户内容
+        filtered_content = filter_user_content(content)
+        save_to_md(filtered_content, md_filename)  # 只保存筛选后的内容
+        return filtered_content
+
+# 自定义CSS样式
+custom_css = """
+h1, h2, h3, h4, h5, h6 {
+    font-family: 'Arial', sans-serif;
+    font-weight: bold;
+}
+body {
+    font-family: 'Arial', sans-serif;
+}
+.gradio-container {
+    max-width: 800px;
+    margin: auto;
+    padding: 20px;
+    border: 1px solid #ccc;
+    border-radius: 10px;
+    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+}
+textarea, input, .btn-primary {
+    font-size: 16px !important;
+    padding: 10px !important;
+    border-radius: 5px !important;
+}
+#component-0 > .wrap > .block.markdown-block > .markdown {
+    font-size: 24px !important;
+    line-height: 1.8 !important;
+}
+"""
+
+iface = gr.Interface(
+    fn=analyze_company,
+    inputs=gr.Textbox(lines=1, placeholder="输入英文公司名称或股票代码"),
+    outputs=gr.Markdown(label="Trade-Helper 股市基本面分析与预测"),
+    title="Trade-Helper",
+    description="请输入公司名称或股票代码，以获取AI的分析和预测报告。",
+    css=custom_css,
+    allow_flagging='never'
+)
+
+if __name__ == "__main__":
+    iface.launch(share=True, server_port=7861)
+

config_api_keys_sample

@@ -0,0 +1,6 @@
+# Fill in your own api keys below, rename this file to config_api_keys and remove this line before you kick off.
+{
+    "FINNHUB_API_KEY": "YOUR_FINNHUB_API_KEY",
+    "FMP_API_KEY": "YOUR_FMP_API_KEY",
+    "SEC_API_KEY": "YOUR_SEC_API_KEY"
+}

configs/save_config_forecaster.json

@@ -0,0 +1,43 @@
+{
+    "building_task": "Gather information like company profile, recent stock price fluctuations, market news, and financial basics of a specified company (e.g. AAPL) by programming and analyze its current positive developments and potential concerns. Based on all the information, come up with a rough estimate (e.g. up by 2-3%) and give a summary of the reasons for next week's stock price. Each python program should execute on its own, and avoid plotting any chart.",
+    "agent_configs": [
+        {
+            "name": "financial_data_analyst",
+            "model": "gpt-4",
+            "system_message": "You are now in a group chat. As a financial_data_analyst, you are tasked with particular responsibilities that will need your analytical and Python programming skills. Be ready to:\n\n    1. Make use of Python to gather relevant data. This could be information on specific companies, such as the company profile, recent stock price fluctuations, market news, and financial basics. The Python code should be able to output this necessary information. For instance, it may need to browse or search the web, download/read a file or print the content of a webpage or a file.\n\n    2. Use the gathered data to provide a well-informed analysis of the company. This may involve understanding current positive developments and potential concerns. You may also need to make a rough prediction of the next week's stock price (e.g., up by 2-3%) and provide an elaborative summary of the reasons. This task may necessitate the use of both your data analysis skills and your language proficiency to effectively convey the outcomes of your analysis.\n\n    3. Ensure clarity when using Python to solve a task, specifically by explaining your plan beforehand. Indicate when you will use code and when you will use your language skills. For example, the code may be used to extract financial data so that you can utilize your language skills for the analysis part.\n\n    4. Eliminate the necessity for the user to make changes to your code. Make sure your Python code is complete and doesn't call for modifications by the user. Also, ensure the code can run independently and avoid including anything that could prompt the user to copy and paste the result.\n\n    5. Be diligent in checking the execution results returned by the user. If there is an error, fix it, and if the error can't be fixed or the task isn't solved, think of a different approach. You can then output the full corrected code once again. \n\n    6. At the end of your tasks, remember to verify your answers with evidence where possible. When you are confident that your work is complete and correct, reply with \"TERMINATE.\"\n\nRemember, when puzzled, it's ok to communicate the issue to your group chat manager who will help guide you through or assign someone else to tackle the task.",
+            "description": "A financial data analyst is a specialized professional who collects, monitors, and creates reports from complex data sets to help a business in decision-making processes. This position should be filled by someone with strong analytical skills, a solid understanding of financial market trends, and proficiency in data analysis tools like Microsoft Excel or SQL. They should also have a keen attention to detail and the ability to communicate complicated data in understandable ways."
+        },
+        {
+            "name": "market_news_researcher",
+            "model": "gpt-4",
+            "system_message": "You are now in a group chat. Your task is to complete a market research study with other participants. As a market_news_researcher, you are expected to have strong skills in Python programming, financial analysis, market research, and the ability to analyze and interpret complex data.\n\n    1. Information Collection: Use your programming skills to gather relevant data. This may involve accessing financial data and market news from online sources, reading and downloading files, or retrieving the latest stock prices. Ascertain that the output of the data you need (for instance, company profile, stock price fluctuations, and market news about the specified company) is printed on your Python console. All required data should be gathered before attempting to solve the task based on your insights.\n        \n    2. Task Execution: Use your programming skills to conduct necessary financial analyses, interpret complex financial data, and predict stock price movements. Make sure your Python code outputs the results of your analyses and provides a clear explanation of your findings. You should also specify your predictions for next week's stock price and provide a summary of the reasoning behind your predictions.\n        \n    3. Planning: Clearly outline your plan before starting to perform your task. Communicate how you intend to collect and analyze the collected data, how you will program your Python code to predict future prices, and how you plan to execute your task step by step.\n        \n    4. Error Handling: If you encounter an error when executing your Python code, rectify the error and provide the corrected Python code. Ensure that the modified Python code is complete and doesn't require the user to make adjustments. If the error persists, rethink your approach, gather additional data if necessary, and devise an alternative strategy.\n        \n    5. Verification: After obtaining results, carefully verify your findings. If possible, provide supporting evidence in your response.\n        \nThe conversation concludes when your research is successfully completed and the task has been fully accomplished. At this point, reply \"TERMINATE\". Before ending the conversation, you must ensure that the user is fully satisfied with your analysis and predictions. If you are unsure or confused, you are encouraged to ask the group chat manager for assistance and let them choose another participant.",
+            "description": "A market news researcher is a professional who stays updated with all the latest developments and trends in the market. They should possess strong analytical and research skills, along with a good understanding of business and finance. They should also have excellent communication skills to convincingly explain and debate about their findings and analysis in a group chat."
+        },
+        {
+            "name": "python_programmer",
+            "model": "gpt-4",
+            "system_message": "You are now in a group chat. You have been assigned a task along with other participants. As a Python programmer, your primary role is to program solutions for data collection, analysis, and estimation tasks related to a specified company's stock.\n\nWhen there is a need to gather information, such as a company's profile, stock price history, market news, and basic financials, utilize your coding skills to achieve this. Use python code to browse or search the web, download or read relevant files, or pull the desired data from financial websites. Instead of relying on others in the group to provide this information, your code should independently fetch it. Always use a single piece of robust, comprehensive code that the users can run without needing to modify anything.\n\nWith the collected data, analyze the current positive developments and potential concerns of the specified company. Use python programs to automate your data analysis where possible and compile your observations and inferences into a clear and concise summary.\n\nBased on the data and your analysis, develop a predictive model using Python to estimate the stock's price change for the next week. Explain your model's rationale and output a numerical estimate, e.g., \"up by 2-3%\". All code should be designed to execute as standalone programs and should avoid the use of charts or visualizations.\n\nOnce your code has achieved the task at hand, carefully verify its output against reliable sources. Include any evidence or references that support your findings.\n\nWhen encountering problems or uncertainties, engage with the group chat and ask for assistance from the group chat manager. Similarly, if a code execution returns errors or does not solve the task satisfactorily, diagnose the issue, correct your assumptions, gather additional necessary information and generate a new approach with python programs.\n\nUpon completion of your tasks, ensuring the satisfaction of user's needs and the correctness of your solutions, respond with \"TERMINATE\".",
+            "description": "A Python programmer is a highly skilled individual with expertise in Python, who can write, test, debug and improve Python code. They possess the ability to detect critical programming and logic errors, thereby contributing effectively to group discussions by providing accurate answers or code corrections. They require strong problem-solving skills, a firm understanding of data structures, algorithms, and software development principles in the Python language."
+        },
+        {
+            "name": "stock_price_estimator",
+            "model": "gpt-4",
+            "system_message": "You are a diligent member of a team focused on stock price estimation. Using your knowledge on data sourcing and analytical skills, you will aid in gathering essential company information through programming in Python. Conduct thorough research on specific company profiles (e.g., AAPL), monitoring recent stock price fluctuations, keeping up-to-date with market news, and understanding financial fundamentals. \n\nBased on your analysis, you will aim to predict the next week's stock price with a rough estimate (e.g., up 2-3%). Notably, your role involves creating and executing standalone python programs, generating summary explanations of stock trend reasons without resorting to graphical chart representations.\n\nCarefully, step-by-step:\n\n1. Employ your Python coding skills to gather necessary information. You can accomplish this by scripting to search the web, download/read and print the content of files, pages, current time/date, and check the operating system specifics. Execute your scripts and share the output.\n\n2. Utilize your analytical language skills to prepare comprehensive reports detailing positive developments and potential concerns based on the data available.\n\n3. Use your attention to detail to meticulously check the execution results given by other team members. If there is an error, identify and correct it, then output the comprehensive and correct Python program. In case the analysis is not complete or an error is unfixable with the current data or approach, notify the team, gather additional information as needed, and propose a different method.\n\n4. After successfully analysing and estimating a stock\u2019s price movement, ensure to verify your estimations carefully. If possible, include convincing evidence in your report.\n\n5. Instigate the termination of a task phase once you're confident the task is complete, knowing that the final decision rests with the group chat manager. \n\n6. If stumped or uncertain, refrain from hesitation. Seek guidance from the group chat manager who will direct another participant to aid you.\n\nBear in mind; coding skills are limited to Python. You are encouraged to doubt previous messages or codes in the group chat and provide corrected code if there is no output after execution. Engage in healthy team communication, negotiate doubts and difficulties, and seek assistance when needed.",
+            "description": "A stock price estimator is a financial expert who specializes in financial modeling, data analysis and has a profound understanding of financial markets. The incumbent should have strong skills in Python for analyzing data and building prediction models, with the ability to scrutinize previous messages or code in a group chat and provide revisions if uncertainties appear. Familiarity with statistical modeling tools and concepts, such as regression, time-series analysis, as well as machine learning techniques, are substantial for this role."
+        },
+        {
+            "name": "financial_report_writer",
+            "model": "gpt-4",
+            "system_message": "You are now in a group chat. Your role is to complete a task with other participants. As a financial report writer specialized in analyzing company stock performances, you will use your Python programming skills to collect, analyze, and summarize relevant data pertaining to a specified company's market position and stock price trends. \n\nYou are expected to perform the following functions:\n\n    1. Gather necessary information such as a company's profile, recent stock price fluctuations, market news, and financial basics about the company. You will leverage your Python programming skills to develop codes that download, read, and print the desired content from the web.\n\n    2. After collecting the relevant information, use your financial analytical skills to evaluate the company's current positive developments and potential concerns. Your evaluation should be based on the data you have gathered.\n\n    3. When your analysis is complete, give a rough estimate (e.g., up by 2-3%) for the next week's stock price. You should also provide a summary of the reasons for your prediction.\n\n    4. Make sure every Python program you create will execute on its own. Avoid designing programs that require the user to modify your code. Each Python program you suggest should not involve chart plotting.\n\n    5. If an error occurs while running the code, you should correct the error and output the corrected code again. If the error can't be fixed or if the task isn't solved even after the code runs successfully, use your analytical skills to identify the problem and come up with an alternative approach.\n\n    6. Verify your answer carefully before presenting it. Include evidence to validate your findings, where possible.\n\n    7. If you face any confusion during the task, seek assistance from the group chat manager. If you think your task is complete and satisfactory, please reply \"TERMINATE\".",
+            "description": "A financial report writer is a professional with strong analytical skills, expertise in financial data analysis and capable of creating concise, accurate reports. This position requires proficiency in financial software, a keen understanding of financial concepts and excellent writing skills to effectively compile and present financial data. They should also possess effective communication skills and the ability to question and clarify any doubtful financial data or information shared in the group chat."
+        }
+    ],
+    "coding": true,
+    "default_llm_config": {
+        "temperature": 0
+    },
+    "code_execution_config": {
+        "work_dir": "coding",
+        "use_docker": false
+    }
+}

finrobot/agents/__init__.py

@@ -0,0 +1 @@
+

finrobot/agents/agent_library.py

@@ -0,0 +1,97 @@
+from finrobot.data_source import *
+from finrobot.functional import *
+from textwrap import dedent
+
+library = [
+    {
+        "name": "Software_Developer",
+        "profile": "As a Software Developer for this position, you must be able to work collaboratively in a group chat environment to complete tasks assigned by a leader or colleague, primarily using Python programming expertise, excluding the need for code interpretation skills.",
+    },
+    {
+        "name": "Data_Analyst",
+        "profile": "As a Data Analyst for this position, you must be adept at analyzing data using Python, completing tasks assigned by leaders or colleagues, and collaboratively solving problems in a group chat setting with professionals of various roles. Reply 'TERMINATE' when everything is done.",
+    },
+    {
+        "name": "Programmer",
+        "profile": "As a Programmer for this position, you should be proficient in Python, able to effectively collaborate and solve problems within a group chat environment, and complete tasks assigned by leaders or colleagues without requiring expertise in code interpretation.",
+    },
+    {
+        "name": "Accountant",
+        "profile": "As an accountant in this position, one should possess a strong proficiency in accounting principles, the ability to effectively collaborate within team environments, such as group chats, to solve tasks, and have a basic understanding of Python for limited coding tasks, all while being able to follow directives from leaders and colleagues.",
+    },
+    {
+        "name": "Statistician",
+        "profile": "As a Statistician, the applicant should possess a strong background in statistics or mathematics, proficiency in Python for data analysis, the ability to work collaboratively in a team setting through group chats, and readiness to tackle and solve tasks delegated by supervisors or peers.",
+    },
+    {
+        "name": "IT_Specialist",
+        "profile": "As an IT Specialist, you should possess strong problem-solving skills, be able to effectively collaborate within a team setting through group chats, complete tasks assigned by leaders or colleagues, and have proficiency in Python programming, excluding the need for code interpretation expertise.",
+    },
+    {
+        "name": "Artificial_Intelligence_Engineer",
+        "profile": "As an Artificial Intelligence Engineer, you should be adept in Python, able to fulfill tasks assigned by leaders or colleagues, and capable of collaboratively solving problems in a group chat with diverse professionals.",
+    },
+    {
+        "name": "Financial_Analyst",
+        "profile": "As a Financial Analyst, one must possess strong analytical and problem-solving abilities, be proficient in Python for data analysis, have excellent communication skills to collaborate effectively in group chats, and be capable of completing assignments delegated by leaders or colleagues.",
+    },
+    {
+        "name": "Market_Analyst",
+        "profile": "As a Market Analyst, one must possess strong analytical and problem-solving abilities, collect necessary financial information and aggregate them based on client's requirement. For coding tasks, only use the functions you have been provided with. Reply TERMINATE when the task is done.",
+        "toolkits": [
+            {
+                "function": FinnHubUtils.get_company_profile,
+                "name": "get_company_profile",
+                "description": "get a company's profile information",
+            },
+            {
+                "function": FinnHubUtils.get_company_news,
+                "name": "get_company_news",
+                "description": "retrieve market news related to designated company",
+            },
+            {
+                "function": FinnHubUtils.get_basic_financials,
+                "name": "get_financial_basics",
+                "description": "get latest financial basics for a designated company",
+            },
+            {
+                "function": YFinanceUtils.get_stock_data,
+                "name": "get_stock_data",
+                "description": "retrieve stock price data for designated ticker symbol",
+            },
+        ],
+    },
+    {
+        "name": "Expert_Investor",
+        "profile": dedent(
+            f"""
+            Role: Expert Investor
+            Department: Finance
+            Primary Responsibility: Generation of Customized Financial Analysis Reports
+
+            Role Description:
+            As an Expert Investor within the finance domain, your expertise is harnessed to develop bespoke Financial Analysis Reports that cater to specific client requirements. This role demands a deep dive into financial statements and market data to unearth insights regarding a company's financial performance and stability. Engaging directly with clients to gather essential information and continuously refining the report with their feedback ensures the final product precisely meets their needs and expectations.
+
+            Key Objectives:
+
+            Analytical Precision: Employ meticulous analytical prowess to interpret financial data, identifying underlying trends and anomalies.
+            Effective Communication: Simplify and effectively convey complex financial narratives, making them accessible and actionable to non-specialist audiences.
+            Client Focus: Dynamically tailor reports in response to client feedback, ensuring the final analysis aligns with their strategic objectives.
+            Adherence to Excellence: Maintain the highest standards of quality and integrity in report generation, following established benchmarks for analytical rigor.
+            Performance Indicators:
+            The efficacy of the Financial Analysis Report is measured by its utility in providing clear, actionable insights. This encompasses aiding corporate decision-making, pinpointing areas for operational enhancement, and offering a lucid evaluation of the company's financial health. Success is ultimately reflected in the report's contribution to informed investment decisions and strategic planning.
+
+            Reply TERMINATE when everything is settled.
+            """
+        ),
+        "toolkits": [
+            FMPUtils.get_sec_report,  # Retrieve SEC report url and filing date
+            IPythonUtils.display_image,  # Display image in IPython
+            TextUtils.check_text_length,  # Check text length
+            ReportLabUtils.build_annual_report,  # Build annual report in designed pdf format
+            ReportAnalysisUtils,  # Expert Knowledge for Report Analysis
+            ReportChartUtils,  # Expert Knowledge for Report Chart Plotting
+        ],
+    },
+]
+library = {d["name"]: d for d in library}

finrobot/agents/utils.py

@@ -0,0 +1,12 @@
+def order_trigger(sender):
+    # Check if the last message contains the path to the instruction text file
+    return "instruction & resources saved to" in sender.last_message()["content"]
+
+
+def order_message(recipient, messages, sender, config):
+    # Extract the path to the instruction text file from the last message
+    full_order = recipient.chat_messages_for_summary(sender)[-1]["content"]
+    txt_path = full_order.replace("instruction & resources saved to ", "").strip()
+    with open(txt_path, "r") as f:
+        instruction = f.read() + "\n\nReply TERMINATE at the end of your response."
+    return instruction

finrobot/agents/workflow.py

@@ -0,0 +1,175 @@
+from .agent_library import library
+from typing import Any, Callable, Dict, List, Literal
+import autogen
+from autogen.cache import Cache
+from autogen.agentchat.contrib.retrieve_user_proxy_agent import RetrieveUserProxyAgent
+
+from ..toolkits import register_toolkits
+from .utils import *
+
+
+class FinRobot(autogen.AssistantAgent):
+
+    def __init__(
+        self,
+        name: str,
+        system_message: str | None = None,
+        toolkits: List[Callable | dict | type] = [],
+        proxy: autogen.UserProxyAgent | None = None,
+        **kwargs,
+    ):
+        orig_name = name
+        name = name.replace("_Shadow", "")
+        assert name in library, f"FinRobot {name} not found in agent library."
+
+        default_toolkits = library[name].get("toolkits", [])
+        default_system_message = library[name].get("profile", "")
+
+        self.toolkits = toolkits or default_toolkits
+        system_message = system_message or default_system_message
+
+        assert bool(system_message), f"System message is required for {name}."
+
+        super().__init__(orig_name, system_message, **kwargs)
+        if proxy is not None:
+            register_toolkits(self.toolkits, self, proxy)
+
+
+from autogen.agentchat.contrib.retrieve_assistant_agent import RetrieveAssistantAgent
+
+
+class SingleAssistant:
+
+    def __init__(
+        self,
+        name: str,
+        llm_config: Dict[str, Any] = {},
+        is_termination_msg=lambda x: x.get("content", "")
+        and x.get("content", "").endswith("TERMINATE"),
+        human_input_mode="NEVER",
+        max_consecutive_auto_reply=10,
+        code_execution_config={
+            "work_dir": "coding",
+            "use_docker": False,
+        },
+        **kwargs,
+    ):
+
+        self.user_proxy = autogen.UserProxyAgent(
+            name="User_Proxy",
+            is_termination_msg=is_termination_msg,
+            human_input_mode=human_input_mode,
+            max_consecutive_auto_reply=max_consecutive_auto_reply,
+            code_execution_config=code_execution_config,
+            **kwargs,
+        )
+        self.assistant = FinRobot(
+            name,
+            llm_config=llm_config,
+            proxy=self.user_proxy,
+        )
+
+    def chat(self, message: str, use_cache=False, **kwargs):
+        with Cache.disk() as cache:
+            self.user_proxy.initiate_chat(
+                self.assistant,
+                message=message,
+                cache=cache if use_cache else None,
+                **kwargs,
+            )
+
+
+class SingleAssistantRAG:
+
+    def __init__(
+        self,
+        name: str,
+        llm_config: Dict[str, Any] = {},
+        is_termination_msg=lambda x: x.get("content", "")
+        and x.get("content", "").endswith("TERMINATE"),
+        human_input_mode="NEVER",
+        max_consecutive_auto_reply=10,
+        code_execution_config={
+            "work_dir": "coding",
+            "use_docker": False,
+        },
+        retrieve_config=None,
+        **kwargs,
+    ):
+        self.user_proxy = RetrieveUserProxyAgent(
+            name="User_Proxy",
+            is_termination_msg=is_termination_msg,
+            human_input_mode=human_input_mode,
+            max_consecutive_auto_reply=max_consecutive_auto_reply,
+            code_execution_config=code_execution_config,
+            retrieve_config=retrieve_config,
+            **kwargs,
+        )
+        self.assistant = FinRobot(
+            name,
+            llm_config=llm_config,
+            proxy=self.user_proxy,
+        )
+
+    def chat(self, message: str, use_cache=False, **kwargs):
+        with Cache.disk() as cache:
+            self.user_proxy.initiate_chat(
+                self.assistant,
+                message=self.user_proxy.message_generator,
+                problem=message,
+                cache=cache if use_cache else None,
+                **kwargs,
+            )
+
+
+class SingleAssistantShadow(SingleAssistant):
+
+    def __init__(
+        self,
+        name: str,
+        llm_config: Dict[str, Any] = {},
+        is_termination_msg=lambda x: x.get("content", "")
+        and x.get("content", "").endswith("TERMINATE"),
+        human_input_mode="NEVER",
+        max_consecutive_auto_reply=10,
+        code_execution_config={
+            "work_dir": "coding",
+            "use_docker": False,
+        },
+        **kwargs,
+    ):
+        super().__init__(
+            name,
+            llm_config=llm_config,
+            is_termination_msg=is_termination_msg,
+            human_input_mode=human_input_mode,
+            max_consecutive_auto_reply=max_consecutive_auto_reply,
+            code_execution_config=code_execution_config,
+            **kwargs,
+        )
+        self.assistant = FinRobot(
+            name,
+            llm_config=llm_config,
+            is_termination_msg=lambda x: x.get("content", "")
+            and x.get("content", "").endswith("TERMINATE"),
+            proxy=self.user_proxy,
+        )
+        self.assistant_shadow = FinRobot(
+            name + "_Shadow",
+            toolkits=[],
+            llm_config=llm_config,
+            proxy=None,
+        )
+        self.assistant.register_nested_chats(
+            [
+                {
+                    "sender": self.assistant,
+                    "recipient": self.assistant_shadow,
+                    "message": order_message,
+                    "summary_method": "last_msg",
+                    "max_turns": 2,
+                    "silent": True,  # mute the chat summary
+                }
+            ],
+            trigger=order_trigger,
+        )

finrobot/data_source/__init__.py

@@ -0,0 +1,13 @@
+import importlib.util
+
+from .finnhub_utils import FinnHubUtils
+from .yfinance_utils import YFinanceUtils
+from .fmp_utils import FMPUtils
+from .sec_utils import SECUtils
+
+if importlib.util.find_spec("finnlp") is not None:
+    from .finnlp_utils import FinNLPUtils
+
+    __all__ = ["FinNLPUtils", "FinnHubUtils", "YFinanceUtils", "FMPUtils", "SECUtils"]
+else:
+    __all__ = ["FinnHubUtils", "YFinanceUtils", "FMPUtils", "SECUtils"]

finrobot/data_source/finnhub_utils.py

@@ -0,0 +1,161 @@
+import os
+import finnhub
+import pandas as pd
+import json
+import random
+from typing import Annotated
+from collections import defaultdict
+from functools import wraps
+from datetime import datetime
+from ..utils import decorate_all_methods, save_output, SavePathType
+
+
+def init_finnhub_client(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        global finnhub_client
+        if os.environ.get("FINNHUB_API_KEY") is None:
+            print(
+                "Please set the environment variable FINNHUB_API_KEY to use the Finnhub API."
+            )
+            return None
+        else:
+            finnhub_client = finnhub.Client(api_key=os.environ["FINNHUB_API_KEY"])
+            print("Finnhub client initialized")
+            return func(*args, **kwargs)
+
+    # wrapper.__annotations__ = func.__annotations__
+    return wrapper
+
+
+@decorate_all_methods(init_finnhub_client)
+class FinnHubUtils:
+
+    def get_company_profile(symbol: Annotated[str, "ticker symbol"]) -> str:
+
+        profile = finnhub_client.company_profile2(symbol=symbol)
+        if not profile:
+            return f"Failed to find company profile for symbol {symbol} from finnhub!"
+
+        formatted_str = (
+            "[Company Introduction]:\n\n{name} is a leading entity in the {finnhubIndustry} sector. "
+            "Incorporated and publicly traded since {ipo}, the company has established its reputation as "
+            "one of the key players in the market. As of today, {name} has a market capitalization "
+            "of {marketCapitalization:.2f} in {currency}, with {shareOutstanding:.2f} shares outstanding."
+            "\n\n{name} operates primarily in the {country}, trading under the ticker {ticker} on the {exchange}. "
+            "As a dominant force in the {finnhubIndustry} space, the company continues to innovate and drive "
+            "progress within the industry."
+        ).format(**profile)
+
+        return formatted_str
+
+    def get_company_news(
+        symbol: Annotated[str, "ticker symbol"],
+        start_date: Annotated[
+            str,
+            "start date of the search period for the company's basic financials, yyyy-mm-dd",
+        ],
+        end_date: Annotated[
+            str,
+            "end date of the search period for the company's basic financials, yyyy-mm-dd",
+        ],
+        max_news_num: Annotated[
+            int, "maximum number of news to return, default to 10"
+        ] = 10,
+        save_path: SavePathType = None,
+    ) -> pd.DataFrame:
+
+        news = finnhub_client.company_news(symbol, _from=start_date, to=end_date)
+        if len(news) == 0:
+            print(f"No company news found for symbol {symbol} from finnhub!")
+        news = [
+            {
+                "date": datetime.fromtimestamp(n["datetime"]).strftime("%Y%m%d%H%M%S"),
+                "headline": n["headline"],
+                "summary": n["summary"],
+            }
+            for n in news
+        ]
+        # Randomly select a subset of news if the number of news exceeds the maximum
+        if len(news) > max_news_num:
+            news = random.choices(news, k=max_news_num)
+        news.sort(key=lambda x: x["date"])
+        output = pd.DataFrame(news)
+        save_output(output, f"company news of {symbol}", save_path=save_path)
+
+        return output
+
+    def get_basic_financials_history(
+        symbol: Annotated[str, "ticker symbol"],
+        freq: Annotated[
+            str,
+            "reporting frequency of the company's basic financials: annual / quarterly",
+        ],
+        start_date: Annotated[
+            str,
+            "start date of the search period for the company's basic financials, yyyy-mm-dd",
+        ],
+        end_date: Annotated[
+            str,
+            "end date of the search period for the company's basic financials, yyyy-mm-dd",
+        ],
+        selected_columns: Annotated[
+            list[str] | None,
+            "List of column names of news to return, should be chosen from 'assetTurnoverTTM', 'bookValue', 'cashRatio', 'currentRatio', 'ebitPerShare', 'eps', 'ev', 'fcfMargin', 'fcfPerShareTTM', 'grossMargin', 'inventoryTurnoverTTM', 'longtermDebtTotalAsset', 'longtermDebtTotalCapital', 'longtermDebtTotalEquity', 'netDebtToTotalCapital', 'netDebtToTotalEquity', 'netMargin', 'operatingMargin', 'payoutRatioTTM', 'pb', 'peTTM', 'pfcfTTM', 'pretaxMargin', 'psTTM', 'ptbv', 'quickRatio', 'receivablesTurnoverTTM', 'roaTTM', 'roeTTM', 'roicTTM', 'rotcTTM', 'salesPerShare', 'sgaToSale', 'tangibleBookValue', 'totalDebtToEquity', 'totalDebtToTotalAsset', 'totalDebtToTotalCapital', 'totalRatio'",
+        ] = None,
+        save_path: SavePathType = None,
+    ) -> pd.DataFrame:
+
+        if freq not in ["annual", "quarterly"]:
+            return f"Invalid reporting frequency {freq}. Please specify either 'annual' or 'quarterly'."
+
+        basic_financials = finnhub_client.company_basic_financials(symbol, "all")
+        if not basic_financials["series"]:
+            return f"Failed to find basic financials for symbol {symbol} from finnhub! Try a different symbol."
+
+        output_dict = defaultdict(dict)
+        for metric, value_list in basic_financials["series"][freq].items():
+            if selected_columns and metric not in selected_columns:
+                continue
+            for value in value_list:
+                if value["period"] >= start_date and value["period"] <= end_date:
+                    output_dict[metric].update({value["period"]: value["v"]})
+
+        financials_output = pd.DataFrame(output_dict)
+        financials_output = financials_output.rename_axis(index="date")
+        save_output(financials_output, "basic financials", save_path=save_path)
+
+        return financials_output
+
+    def get_basic_financials(
+        symbol: Annotated[str, "ticker symbol"],
+        selected_columns: Annotated[
+            list[str] | None,
+            "List of column names of news to return, should be chosen from 'assetTurnoverTTM', 'bookValue', 'cashRatio', 'currentRatio', 'ebitPerShare', 'eps', 'ev', 'fcfMargin', 'fcfPerShareTTM', 'grossMargin', 'inventoryTurnoverTTM', 'longtermDebtTotalAsset', 'longtermDebtTotalCapital', 'longtermDebtTotalEquity', 'netDebtToTotalCapital', 'netDebtToTotalEquity', 'netMargin', 'operatingMargin', 'payoutRatioTTM', 'pb', 'peTTM', 'pfcfTTM', 'pretaxMargin', 'psTTM', 'ptbv', 'quickRatio', 'receivablesTurnoverTTM', 'roaTTM', 'roeTTM', 'roicTTM', 'rotcTTM', 'salesPerShare', 'sgaToSale', 'tangibleBookValue', 'totalDebtToEquity', 'totalDebtToTotalAsset', 'totalDebtToTotalCapital', 'totalRatio','10DayAverageTradingVolume', '13WeekPriceReturnDaily', '26WeekPriceReturnDaily', '3MonthADReturnStd', '3MonthAverageTradingVolume', '52WeekHigh', '52WeekHighDate', '52WeekLow', '52WeekLowDate', '52WeekPriceReturnDaily', '5DayPriceReturnDaily', 'assetTurnoverAnnual', 'assetTurnoverTTM', 'beta', 'bookValuePerShareAnnual', 'bookValuePerShareQuarterly', 'bookValueShareGrowth5Y', 'capexCagr5Y', 'cashFlowPerShareAnnual', 'cashFlowPerShareQuarterly', 'cashFlowPerShareTTM', 'cashPerSharePerShareAnnual', 'cashPerSharePerShareQuarterly', 'currentDividendYieldTTM', 'currentEv/freeCashFlowAnnual', 'currentEv/freeCashFlowTTM', 'currentRatioAnnual', 'currentRatioQuarterly', 'dividendGrowthRate5Y', 'dividendPerShareAnnual', 'dividendPerShareTTM', 'dividendYieldIndicatedAnnual', 'ebitdPerShareAnnual', 'ebitdPerShareTTM', 'ebitdaCagr5Y', 'ebitdaInterimCagr5Y', 'enterpriseValue', 'epsAnnual', 'epsBasicExclExtraItemsAnnual', 'epsBasicExclExtraItemsTTM', 'epsExclExtraItemsAnnual', 'epsExclExtraItemsTTM', 'epsGrowth3Y', 'epsGrowth5Y', 'epsGrowthQuarterlyYoy', 'epsGrowthTTMYoy', 'epsInclExtraItemsAnnual', 'epsInclExtraItemsTTM', 'epsNormalizedAnnual', 'epsTTM', 'focfCagr5Y', 'grossMargin5Y', 'grossMarginAnnual', 'grossMarginTTM', 'inventoryTurnoverAnnual', 'inventoryTurnoverTTM', 'longTermDebt/equityAnnual', 'longTermDebt/equityQuarterly', 'marketCapitalization', 'monthToDatePriceReturnDaily', 'netIncomeEmployeeAnnual', 'netIncomeEmployeeTTM', 'netInterestCoverageAnnual', 'netInterestCoverageTTM', 'netMarginGrowth5Y', 'netProfitMargin5Y', 'netProfitMarginAnnual', 'netProfitMarginTTM', 'operatingMargin5Y', 'operatingMarginAnnual', 'operatingMarginTTM', 'payoutRatioAnnual', 'payoutRatioTTM', 'pbAnnual', 'pbQuarterly', 'pcfShareAnnual', 'pcfShareTTM', 'peAnnual', 'peBasicExclExtraTTM', 'peExclExtraAnnual', 'peExclExtraTTM', 'peInclExtraTTM', 'peNormalizedAnnual', 'peTTM', 'pfcfShareAnnual', 'pfcfShareTTM', 'pretaxMargin5Y', 'pretaxMarginAnnual', 'pretaxMarginTTM', 'priceRelativeToS&P50013Week', 'priceRelativeToS&P50026Week', 'priceRelativeToS&P5004Week', 'priceRelativeToS&P50052Week', 'priceRelativeToS&P500Ytd', 'psAnnual', 'psTTM', 'ptbvAnnual', 'ptbvQuarterly', 'quickRatioAnnual', 'quickRatioQuarterly', 'receivablesTurnoverAnnual', 'receivablesTurnoverTTM', 'revenueEmployeeAnnual', 'revenueEmployeeTTM', 'revenueGrowth3Y', 'revenueGrowth5Y', 'revenueGrowthQuarterlyYoy', 'revenueGrowthTTMYoy', 'revenuePerShareAnnual', 'revenuePerShareTTM', 'revenueShareGrowth5Y', 'roa5Y', 'roaRfy', 'roaTTM', 'roe5Y', 'roeRfy', 'roeTTM', 'roi5Y', 'roiAnnual', 'roiTTM', 'tangibleBookValuePerShareAnnual', 'tangibleBookValuePerShareQuarterly', 'tbvCagr5Y', 'totalDebt/totalEquityAnnual', 'totalDebt/totalEquityQuarterly', 'yearToDatePriceReturnDaily'",
+        ] = None,
+    ) -> str:
+
+        basic_financials = finnhub_client.company_basic_financials(symbol, "all")
+        if not basic_financials["series"]:
+            return f"Failed to find basic financials for symbol {symbol} from finnhub! Try a different symbol."
+
+        output_dict = basic_financials["metric"]
+        for metric, value_list in basic_financials["series"]["quarterly"].items():
+            value = value_list[0]
+            output_dict.update({metric: value["v"]})
+
+        for k in output_dict.keys():
+            if selected_columns and k not in selected_columns:
+                output_dict.pop(k)
+
+        return json.dumps(output_dict, indent=2)
+
+
+if __name__ == "__main__":
+
+    from finrobot.utils import register_keys_from_json
+
+    register_keys_from_json("../../config_api_keys")
+    # print(FinnHubUtils.get_company_profile("AAPL"))
+    # print(FinnHubUtils.get_basic_financials_history("AAPL", "annual", "2019-01-01", "2021-01-01"))
+    print(FinnHubUtils.get_basic_financials("AAPL"))

finrobot/data_source/finnlp_utils.py

@@ -0,0 +1,234 @@
+import os
+from typing import Annotated
+from pandas import DataFrame
+
+from finnlp.data_sources.news.cnbc_streaming import CNBC_Streaming
+from finnlp.data_sources.news.yicai_streaming import Yicai_Streaming
+from finnlp.data_sources.news.investorplace_streaming import InvestorPlace_Streaming
+# from finnlp.data_sources.news.eastmoney_streaming import Eastmoney_Streaming
+
+from finnlp.data_sources.social_media.xueqiu_streaming import Xueqiu_Streaming
+from finnlp.data_sources.social_media.stocktwits_streaming import Stocktwits_Streaming
+# from finnlp.data_sources.social_media.reddit_streaming import Reddit_Streaming
+
+from finnlp.data_sources.news.sina_finance_date_range import Sina_Finance_Date_Range
+from finnlp.data_sources.news.finnhub_date_range import Finnhub_Date_Range
+
+from ..utils import save_output, SavePathType
+
+
+US_Proxy = {
+    "use_proxy": "us_free",
+    "max_retry": 5,
+    "proxy_pages": 5,
+}
+CN_Proxy = {
+    "use_proxy": "china_free",
+    "max_retry": 5,
+    "proxy_pages": 5,
+}
+
+
+def streaming_download(streaming, config, tag, keyword, rounds, selected_columns, save_path):
+    downloader = streaming(config)
+    if hasattr(downloader, 'download_streaming_search'):
+        downloader.download_streaming_search(keyword, rounds)
+    elif hasattr(downloader, 'download_streaming_stock'):
+        downloader.download_streaming_stock(keyword, rounds)
+    else:
+        downloader.download_streaming_all(rounds)
+    # print(downloader.dataframe.columns)
+    selected = downloader.dataframe[selected_columns]
+    save_output(selected, tag, save_path)
+    return selected
+
+
+def date_range_download(date_range, config, tag, start_date, end_date, stock, selected_columns, save_path):
+    downloader = date_range(config)
+    if hasattr(downloader, 'download_date_range_stock'):
+        downloader.download_date_range_stock(start_date, end_date, stock)
+    else:
+        downloader.download_date_range_all(start_date, end_date)
+    if hasattr(downloader, 'gather_content'):
+        downloader.gather_content()
+    # print(downloader.dataframe.columns)
+    selected_news = downloader.dataframe[selected_columns]
+    save_output(selected_news, tag, save_path)
+    return selected_news
+
+
+class FinNLPUtils:
+
+    """
+    Streaming News Download
+    """
+
+    def cnbc_news_download(
+            keyword: Annotated[str, "Keyword to search in news stream"],
+            rounds: Annotated[int, "Number of rounds to search. Default to 1"] = 1,
+            selected_columns: Annotated[list[str], "List of column names of news to return, should be chosen from 'description', 'cn:lastPubDate', 'dateModified', 'cn:dateline', 'cn:branding', 'section', 'cn:type', 'author', 'cn:source', 'cn:subtype', 'duration', 'summary', 'expires', 'cn:sectionSubType', 'cn:contentClassification', 'pubdateunix', 'url', 'datePublished', 'cn:promoImage', 'cn:title', 'cn:keyword', 'cn:liveURL', 'brand', 'hint', 'hint_detail'. Default to ['author', 'datePublished', 'description' ,'section', 'cn:title', 'summary']"] = ["author", "datePublished", "description" ,"section", "cn:title", "summary"],
+            save_path: SavePathType = None
+        ) -> DataFrame:
+        return streaming_download(CNBC_Streaming, {}, "CNBC News", keyword, rounds, selected_columns, save_path)
+
+
+    def yicai_news_download(
+            keyword: Annotated[str, "Keyword to search in news stream"],
+            rounds: Annotated[int, "Number of rounds to search. Default to 1"] = 1,
+            selected_columns: Annotated[list[str], "List of column names of news to return, should be chosen from 'author','channelid','creationDate','desc','id','previewImage','source','tags','title','topics','typeo','url','weight'. Default to ['author', 'creationDate', 'desc' ,'source', 'title']"] = ["author", "creationDate", "desc" ,"source", "title"],
+            save_path: SavePathType = None
+        ) -> DataFrame:
+        return streaming_download(Yicai_Streaming, {}, "Yicai News", keyword, rounds, selected_columns, save_path)
+
+
+    def investor_place_news_download(
+            keyword: Annotated[str, "Keyword to search in news stream"],
+            rounds: Annotated[int, "Number of rounds to search. Default to 1"] = 1,
+            selected_columns: Annotated[list[str], "List of column names of news to return, should be chosen from 'title', 'time', 'author', 'summary'. Default to ['title', 'time', 'author', 'summary']"] = ['title', 'time', 'author', 'summary'],
+            save_path: SavePathType = None
+        ) -> DataFrame:
+        return streaming_download(InvestorPlace_Streaming, {}, "Investor Place News", keyword, rounds, selected_columns, save_path)
+
+
+    # def eastmoney_news_download(
+    #     stock: Annotated[str, "stock code, e.g. 600519"],
+    #     pages: Annotated[int, "Number of pages to retrieve. Default to 1"] = 1,
+    #     selected_columns: Annotated[list[str], "List of column names of news to return, should be chosen from 'title', 'time', 'author', 'summary'. Default to ['title', 'time', 'author', 'summary']"] = ['title', 'time', 'author', 'summary'],
+    #     verbose: Annotated[bool, "Whether to print downloaded news to console. Default to True"] = True,
+    #     save_path: Annotated[str, "If specified (recommended if the amount of news is large), the downloaded news will be saved to save_path, otherwise the news will be returned as a string. Default to None"] = None,
+    # ) -> str:
+    #     return streaming_download(Eastmoney_Streaming, "Eastmoney", stock, pages, selected_columns, save_path)
+
+
+    """
+    Date Range News Download
+    """
+
+    def sina_finance_news_download(
+            start_date: Annotated[str, "Start date of the news to retrieve, YYYY-mm-dd"],
+            end_date: Annotated[str, "End date of the news to retrieve, YYYY-mm-dd"],
+            selected_columns: Annotated[list[str], """
+                List of column names of news to return, should be chosen from 
+                'mediaid', 'productid', 'summary', 'ctime', 'url', 'author', 'stitle',
+                'authoruid', 'wapsummary', 'images', 'level', 'keywords', 'mlids',
+                'wapurl', 'columnid', 'oid', 'img', 'subjectid', 'commentid',
+                'ipad_vid', 'vid', 'video_id', 'channelid', 'intime',
+                'video_time_length', 'categoryid', 'hqChart', 'intro', 'is_cre_manual',
+                'icons', 'mtime', 'media_name', 'title', 'docid', 'urls', 'templateid', 
+                'lids', 'wapurls', 'ext', 'comment_reply', 'comment_show', 'comment_total', 'praise',
+                'dispraise', 'important', 'content'. Default to ['title', 'author', 'content']
+                """
+            ] = ['title', 'author', 'content'],
+            save_path: SavePathType = None
+        ) -> DataFrame:
+        return date_range_download(Sina_Finance_Date_Range, {}, "Sina Finance News", start_date, end_date, None, selected_columns, save_path)
+
+
+    def finnhub_news_download(
+            start_date: Annotated[str, "Start date of the news to retrieve, YYYY-mm-dd"],
+            end_date: Annotated[str, "End date of the news to retrieve, YYYY-mm-dd"],
+            stock: Annotated[str, "Stock symbol, e.g. AAPL"],
+            selected_columns: Annotated[list[str], "List of column names of news to return, should be chosen from 'category', 'datetime', 'headline', 'id', 'image', 'related', 'source', 'summary', 'url', 'content'. Default to ['headline', 'datetime', 'source', 'summary']"] = ['headline', 'datetime', 'source', 'summary'],
+            save_path: SavePathType = None
+        ) -> DataFrame:
+        return date_range_download(Finnhub_Date_Range, {"token": os.environ['FINNHUB_API_KEY']}, "Finnhub News", start_date, end_date, stock, selected_columns, save_path)
+
+
+    """
+    Social Media
+    """
+    def xueqiu_social_media_download(
+            stock: Annotated[str, "Stock symbol, e.g. 'AAPL'"],
+            rounds: Annotated[int, "Number of rounds to search. Default to 1"] = 1,
+            selected_columns: Annotated[list[str], """
+                List of column names of news to return, should be chosen from blocked', 
+                'blocking', 'canEdit', 'commentId', 'controversial',
+                'created_at', 'description', 'donate_count', 'donate_snowcoin',
+                'editable', 'expend', 'fav_count', 'favorited', 'flags', 'flagsObj',
+                'hot', 'id', 'is_answer', 'is_bonus', 'is_refused', 'is_reward',
+                'is_ss_multi_pic', 'legal_user_visible', 'like_count', 'liked', 'mark',
+                'pic', 'promotion_id', 'reply_count', 'retweet_count',
+                'retweet_status_id', 'reward_count', 'reward_user_count', 'rqid',
+                'source', 'source_feed', 'source_link', 'target', 'text', 'timeBefore',
+                'title', 'trackJson', 'truncated', 'truncated_by', 'type', 'user',
+                'user_id', 'view_count', 'firstImg', 'pic_sizes', 'edited_at'. 
+                Default to ['created_at', 'description', 'title', 'text', 'target', 'source']
+            """] = ['created_at', 'description', 'title', 'text', 'target', 'source'],
+            save_path: SavePathType = None
+        ) -> DataFrame:
+        return streaming_download(Xueqiu_Streaming, {}, "Xueqiu Social Media", stock, rounds, selected_columns, save_path)
+
+
+    def stocktwits_social_media_download(
+            stock: Annotated[str, "Stock symbol, e.g. 'AAPL'"],
+            rounds: Annotated[int, "Number of rounds to search. Default to 1"] = 1,
+            selected_columns: Annotated[list[str], """
+                List of column names of news to return, should be chosen from 'id', 
+                'body', 'created_at', 'user', 'source', 'symbols', 'prices',
+                'mentioned_users', 'entities', 'liked_by_self', 'reshared_by_self',
+                'conversation', 'links', 'likes', 'reshare_message', 'structurable',
+                'reshares'. Default to ['created_at', 'body']
+            """] = ['created_at', 'body'],
+            save_path: SavePathType = None
+        ) -> DataFrame:
+        return streaming_download(Stocktwits_Streaming, {}, "Stocktwits Social Media", stock, rounds, selected_columns, save_path)
+
+
+    # def reddit_social_media_download(
+    #     pages: Annotated[int, "Number of pages to retrieve. Default to 1"] = 1,
+    #     selected_columns: Annotated[list[str], """
+    #         List of column names of news to return, should be chosen from 'id', 
+    #         'body', 'created_at', 'user', 'source', 'symbols', 'prices',
+    #         'mentioned_users', 'entities', 'liked_by_self', 'reshared_by_self',
+    #         'conversation', 'links', 'likes', 'reshare_message', 'structurable',
+    #         'reshares'. Default to ['created_at', 'body']
+    #     """] = ['created_at', 'body'],
+    #     verbose: Annotated[bool, "Whether to print downloaded news to console. Default to True"] = True,
+    #     save_path: Annotated[str, "If specified (recommended if the amount of news is large), the downloaded news will be saved to save_path. Default to None"] = None,
+    # ) -> DataFrame:
+    #     return streaming_download(Reddit_Streaming, {}, "Reddit Social Media", None, pages, selected_columns, save_path)
+
+
+    """
+    Company Announcements
+    (Not working well)
+    """
+
+    # from finnlp.data_sources.company_announcement.sec import SEC_Announcement
+    # from finnlp.data_sources.company_announcement.juchao import Juchao_Announcement
+
+
+    # def sec_announcement_download(
+    #     start_date: Annotated[str, "Start date of the news to retrieve, YYYY-mm-dd"],
+    #     end_date: Annotated[str, "End date of the news to retrieve, YYYY-mm-dd"],
+    #     stock: Annotated[str, "Stock symbol, e.g. AAPL"],
+    #     selected_columns: Annotated[list[str], "List of column names of news to return, should be chosen from 'category', 'datetime', 'headline', 'id', 'image', 'related', 'source', 'summary', 'url', 'content'. Default to ['headline', 'datetime', 'source', 'summary']"] = ['headline', 'datetime', 'source', 'summary'],
+    #     verbose: Annotated[bool, "Whether to print downloaded news to console. Default to True"] = True,
+    #     save_path: Annotated[str, "If specified (recommended if the amount of news is large), the downloaded news will be saved to save_path. Default to None"] = None,
+    # ) -> DataFrame:
+    #     return date_range_download(SEC_Announcement, {}, "SEC Announcements", start_date, end_date, stock, selected_columns, save_path)
+
+
+    # def juchao_announcement_download(
+    #     start_date: Annotated[str, "Start date of the news to retrieve, YYYY-mm-dd"],
+    #     end_date: Annotated[str, "End date of the news to retrieve, YYYY-mm-dd"],
+    #     stock: Annotated[str, "Stock code, e.g. 000001"],
+    #     selected_columns: Annotated[list[str], "List of column names of news to return, should be chosen from 'category', 'datetime', 'headline', 'id', 'image', 'related', 'source', 'summary', 'url', 'content'. Default to ['headline', 'datetime', 'source', 'summary']"] = ['headline', 'datetime', 'source', 'summary'],
+    #     verbose: Annotated[bool, "Whether to print downloaded news to console. Default to True"] = True,
+    #     save_path: Annotated[str, "If specified (recommended if the amount of news is large), the downloaded news will be saved to save_path. Default to None"] = None,
+    # ) -> DataFrame:
+    #     return date_range_download(Juchao_Announcement, {}, "Juchao Announcements", start_date, end_date, stock, selected_columns, save_path)
+
+
+if __name__ == "__main__":
+
+    print(FinNLPUtils.yicai_news_download("茅台", save_path="yicai_maotai.csv"))
+    # print(cnbc_news_download("tesla", save_path="cnbc_tesla.csv"))
+    # investor_place_news_download("tesla", save_path="invpl_tesla.csv")
+    # eastmoney_news_download("600519", save_path="estmny_maotai.csv")
+    # sina_finance_news_download("2024-03-02", "2024-03-02", save_path="sina_news.csv")
+    # finnhub_news_download("2024-03-02", "2024-03-02", "AAPL", save_path="finnhub_aapl_news.csv")
+    # stocktwits_social_media_download("AAPL", save_path="stocktwits_aapl.csv")
+    # xueqiu_social_media_download("茅台", save_path="xueqiu_maotai.csv")
+    # reddit_social_media_download(save_path="reddit_social_media.csv")
+    # juchao_announcement_download("000001", "2020-01-01", "2020-06-01", save_path="sec_announcement.csv")

finrobot/data_source/fmp_utils.py

@@ -0,0 +1,200 @@
+import os
+import requests
+import numpy as np
+import pandas as pd
+from datetime import datetime, timedelta
+from ..utils import decorate_all_methods, get_next_weekday
+
+# from finrobot.utils import decorate_all_methods, get_next_weekday
+from functools import wraps
+from typing import Annotated
+
+
+def init_fmp_api(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        global fmp_api_key
+        if os.environ.get("FMP_API_KEY") is None:
+            print("Please set the environment variable FMP_API_KEY to use the FMP API.")
+            return None
+        else:
+            fmp_api_key = os.environ["FMP_API_KEY"]
+            print("FMP api key found successfully.")
+            return func(*args, **kwargs)
+
+    return wrapper
+
+
+@decorate_all_methods(init_fmp_api)
+class FMPUtils:
+
+    def get_target_price(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        date: Annotated[str, "date of the target price, should be 'yyyy-mm-dd'"],
+    ) -> str:
+        """Get the target price for a given stock on a given date"""
+        # API URL
+        url = f"https://financialmodelingprep.com/api/v4/price-target?symbol={ticker_symbol}&apikey={fmp_api_key}"
+
+        # 发送GET请求
+        price_target = "Not Given"
+        response = requests.get(url)
+
+        # 确保请求成功
+        if response.status_code == 200:
+            # 解析JSON数据
+            data = response.json()
+            est = []
+
+            date = datetime.strptime(date, "%Y-%m-%d")
+            for tprice in data:
+                tdate = tprice["publishedDate"].split("T")[0]
+                tdate = datetime.strptime(tdate, "%Y-%m-%d")
+                if abs((tdate - date).days) <= 1:
+                    est.append(tprice["priceTarget"])
+
+            if est:
+                price_target = f"{np.min(est)} - {np.max(est)} (md. {np.median(est)})"
+            else:
+                price_target = "N/A"
+        else:
+            return f"Failed to retrieve data: {response.status_code}"
+
+        return price_target
+
+    def get_sec_report(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        fyear: Annotated[
+            str,
+            "year of the 10-K report, should be 'yyyy' or 'latest'. Default to 'latest'",
+        ] = "latest",
+    ) -> str:
+        """Get the url and filing date of the 10-K report for a given stock and year"""
+
+        url = f"https://financialmodelingprep.com/api/v3/sec_filings/{ticker_symbol}?type=10-k&page=0&apikey={fmp_api_key}"
+
+        # 发送GET请求
+        filing_url = None
+        response = requests.get(url)
+
+        # 确保请求成功
+        if response.status_code == 200:
+            # 解析JSON数据
+            data = response.json()
+            # print(data)
+            if fyear == "latest":
+                filing_url = data[0]["finalLink"]
+                filing_date = data[0]["fillingDate"]
+            else:
+                for filing in data:
+                    if filing["fillingDate"].split("-")[0] == fyear:
+                        filing_url = filing["finalLink"]
+                        filing_date = filing["fillingDate"]
+                        break
+
+            return f"Link: {filing_url}\nFiling Date: {filing_date}"
+        else:
+            return f"Failed to retrieve data: {response.status_code}"
+
+    def get_historical_market_cap(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        date: Annotated[str, "date of the market cap, should be 'yyyy-mm-dd'"],
+    ) -> str:
+        """Get the historical market capitalization for a given stock on a given date"""
+        date = get_next_weekday(date).strftime("%Y-%m-%d")
+        url = f"https://financialmodelingprep.com/api/v3/historical-market-capitalization/{ticker_symbol}?limit=100&from={date}&to={date}&apikey={fmp_api_key}"
+
+        # 发送GET请求
+        mkt_cap = None
+        response = requests.get(url)
+
+        # 确保请求成功
+        if response.status_code == 200:
+            # 解析JSON数据
+            data = response.json()
+            mkt_cap = data[0]["marketCap"]
+            return mkt_cap
+        else:
+            return f"Failed to retrieve data: {response.status_code}"
+
+    def get_historical_bvps(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        target_date: Annotated[str, "date of the BVPS, should be 'yyyy-mm-dd'"],
+    ) -> str:
+        """Get the historical book value per share for a given stock on a given date"""
+        # 从FMP API获取历史关键财务指标数据
+        url = f"https://financialmodelingprep.com/api/v3/key-metrics/{ticker_symbol}?limit=40&apikey={fmp_api_key}"
+        response = requests.get(url)
+        data = response.json()
+
+        if not data:
+            return "No data available"
+
+        # 找到最接近目标日期的数据
+        closest_data = None
+        min_date_diff = float("inf")
+        target_date = datetime.strptime(target_date, "%Y-%m-%d")
+        for entry in data:
+            date_of_data = datetime.strptime(entry["date"], "%Y-%m-%d")
+            date_diff = abs(target_date - date_of_data).days
+            if date_diff < min_date_diff:
+                min_date_diff = date_diff
+                closest_data = entry
+
+        if closest_data:
+            return closest_data.get("bookValuePerShare", "No BVPS data available")
+        else:
+            return "No close date data found"
+
+    def get_financial_metrics(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        years: Annotated[int, "number of the years to search from, default to 4"] = 4,
+    ):
+        """Get the financial metrics for a given stock for the last 'years' years"""
+        # Base URL setup for FMP API
+        base_url = "https://financialmodelingprep.com/api/v3"
+        # Create DataFrame
+        df = pd.DataFrame()
+
+        # Iterate over the last 'years' years of data
+        for year_offset in range(years):
+            # Construct URL for income statement and ratios for each year
+            income_statement_url = f"{base_url}/income-statement/{ticker_symbol}?limit={years}&apikey={fmp_api_key}"
+            ratios_url = (
+                f"{base_url}/ratios/{ticker_symbol}?limit={years}&apikey={fmp_api_key}"
+            )
+            key_metrics_url = f"{base_url}/key-metrics/{ticker_symbol}?limit={years}&apikey={fmp_api_key}"
+
+            # Requesting data from the API
+            income_data = requests.get(income_statement_url).json()
+            key_metrics_data = requests.get(key_metrics_url).json()
+            ratios_data = requests.get(ratios_url).json()
+
+            # Extracting needed metrics for each year
+            if income_data and key_metrics_data and ratios_data:
+                metrics = {
+                    "Operating Revenue": income_data[year_offset]["revenue"] / 1e6,
+                    "Adjusted Net Profit": income_data[year_offset]["netIncome"] / 1e6,
+                    "Adjusted EPS": income_data[year_offset]["eps"],
+                    "EBIT Margin": ratios_data[year_offset]["ebitPerRevenue"],
+                    "ROE": key_metrics_data[year_offset]["roe"],
+                    "PE Ratio": ratios_data[year_offset]["priceEarningsRatio"],
+                    "EV/EBITDA": key_metrics_data[year_offset][
+                        "enterpriseValueOverEBITDA"
+                    ],
+                    "PB Ratio": key_metrics_data[year_offset]["pbRatio"],
+                }
+                # Append the year and metrics to the DataFrame
+                # Extracting the year from the date
+                year = income_data[year_offset]["date"][:4]
+                df[year] = pd.Series(metrics)
+        df = df.sort_index(axis=1)
+        df = df.round(2)
+        return df
+
+
+if __name__ == "__main__":
+    from finrobot.utils import register_keys_from_json
+
+    register_keys_from_json("config_api_keys")
+    FMPUtils.get_sec_report("MSFT", "2023")

finrobot/data_source/sec_utils.py

@@ -0,0 +1,89 @@
+import os
+from sec_api import ExtractorApi
+from functools import wraps
+from typing import Annotated
+from ..utils import SavePathType
+from ..data_source import FMPUtils
+
+
+CACHE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".cache")
+
+
+def init_sec_api(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        global extractor
+        if os.environ.get("SEC_API_KEY") is None:
+            print("Please set the environment variable SEC_API_KEY to use sec_api.")
+            return None
+        else:
+            extractor = ExtractorApi(os.environ["SEC_API_KEY"])
+            print("Sec Api initialized")
+            return func(*args, **kwargs)
+
+    return wrapper
+
+
+class SECUtils:
+
+    @init_sec_api
+    def get_10k_section(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        fyear: Annotated[str, "fiscal year of the 10-K report"],
+        section: Annotated[
+            str | int,
+            "Section of the 10-K report to extract, should be in [1, 1A, 1B, 2, 3, 4, 5, 6, 7, 7A, 8, 9, 9A, 9B, 10, 11, 12, 13, 14, 15]",
+        ],
+        report_address: Annotated[
+            str,
+            "URL of the 10-K report, if not specified, will get report url from fmp api",
+        ] = None,
+        save_path: SavePathType = None,
+    ) -> str:
+        """
+        Get a specific section of a 10-K report from the SEC API.
+        """
+        if isinstance(section, int):
+            section = str(section)
+        if section not in [
+            "1A",
+            "1B",
+            "7A",
+            "9A",
+            "9B",
+        ] + [str(i) for i in range(1, 16)]:
+            raise ValueError(
+                "Section must be in [1, 1A, 1B, 2, 3, 4, 5, 6, 7, 7A, 8, 9, 9A, 9B, 10, 11, 12, 13, 14, 15]"
+            )
+
+        # os.makedirs(f"{self.project_dir}/10k", exist_ok=True)
+
+        # report_name = f"{self.project_dir}/10k/section_{section}.txt"
+
+        # if USE_CACHE and os.path.exists(report_name):
+        #     with open(report_name, "r") as f:
+        #         section_text = f.read()
+        # else:
+        if report_address is None:
+            report_address = FMPUtils.get_sec_report(ticker_symbol, fyear)
+            if report_address.startswith("Link: "):
+                report_address = report_address.lstrip("Link: ").split()[0]
+            else:
+                return report_address  # debug info
+        
+        cache_path = os.path.join(CACHE_PATH, f"sec_utils/{ticker_symbol}_{fyear}_{section}.txt")
+        if os.path.exists(cache_path):
+            with open(cache_path, "r") as f:
+                section_text = f.read()
+        else:
+            section_text = extractor.get_section(report_address, section, "text")
+            os.makedirs(os.path.dirname(cache_path), exist_ok=True)
+            with open(cache_path, "w") as f:
+                f.write(section_text)
+
+        if save_path:
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+            with open(save_path, "w") as f:
+                f.write(section_text)
+
+        return section_text

finrobot/data_source/yfinance_utils.py

@@ -0,0 +1,117 @@
+import yfinance as yf
+from typing import Annotated, Callable, Any, Optional
+from pandas import DataFrame
+from functools import wraps
+
+from ..utils import save_output, SavePathType, decorate_all_methods
+
+
+def init_ticker(func: Callable) -> Callable:
+    """Decorator to initialize yf.Ticker and pass it to the function."""
+
+    @wraps(func)
+    def wrapper(symbol: Annotated[str, "ticker symbol"], *args, **kwargs) -> Any:
+        ticker = yf.Ticker(symbol)
+        return func(ticker, *args, **kwargs)
+
+    return wrapper
+
+
+@decorate_all_methods(init_ticker)
+class YFinanceUtils:
+
+    def get_stock_data(
+        symbol: Annotated[str, "ticker symbol"],
+        start_date: Annotated[
+            str, "start date for retrieving stock price data, YYYY-mm-dd"
+        ],
+        end_date: Annotated[
+            str, "end date for retrieving stock price data, YYYY-mm-dd"
+        ],
+        save_path: SavePathType = None,
+    ) -> DataFrame:
+        ticker = symbol
+        stock_data = ticker.history(start=start_date, end=end_date)
+        save_output(stock_data, f"Stock data for {ticker.ticker}", save_path)
+        return stock_data
+
+    def get_stock_info(
+        symbol: Annotated[str, "ticker symbol"],
+    ) -> dict:
+        """Fetches and returns stock information."""
+        ticker = symbol
+        stock_info = ticker.info
+        return stock_info
+
+    def get_company_info(
+        self,
+        symbol: Annotated[str, "ticker symbol"],
+        save_path: Optional[str] = None,
+    ) -> DataFrame:
+        """Fetches and returns company information as a DataFrame."""
+        ticker = symbol
+        info = ticker.info
+        company_info = {
+            "Company Name": info.get("shortName", "N/A"),
+            "Industry": info.get("industry", "N/A"),
+            "Sector": info.get("sector", "N/A"),
+            "Country": info.get("country", "N/A"),
+            "Website": info.get("website", "N/A"),
+        }
+        company_info_df = DataFrame([company_info])
+        if save_path:
+            company_info_df.to_csv(save_path)
+            print(f"Company info for {ticker.ticker} saved to {save_path}")
+        return company_info_df
+
+    def get_stock_dividends(
+        self,
+        symbol: Annotated[str, "ticker symbol"],
+        save_path: Optional[str] = None,
+    ) -> DataFrame:
+        """Fetches and returns the dividends data as a DataFrame."""
+        ticker = symbol
+        dividends = ticker.dividends
+        if save_path:
+            dividends.to_csv(save_path)
+            print(f"Dividends for {ticker.ticker} saved to {save_path}")
+        return dividends
+
+    def get_income_stmt(symbol: Annotated[str, "ticker symbol"]) -> DataFrame:
+        """Fetches and returns the income statement of the company as a DataFrame."""
+        ticker = symbol
+        income_stmt = ticker.financials
+        return income_stmt
+
+    def get_balance_sheet(symbol: Annotated[str, "ticker symbol"]) -> DataFrame:
+        """Fetches and returns the balance sheet of the company as a DataFrame."""
+        ticker = symbol
+        balance_sheet = ticker.balance_sheet
+        return balance_sheet
+
+    def get_cash_flow(symbol: Annotated[str, "ticker symbol"]) -> DataFrame:
+        """Fetches and returns the cash flow statement of the company as a DataFrame."""
+        ticker = symbol
+        cash_flow = ticker.cashflow
+        return cash_flow
+
+    def get_analyst_recommendations(symbol: Annotated[str, "ticker symbol"]) -> tuple:
+        """Fetches the latest analyst recommendations and returns the most common recommendation and its count."""
+        ticker = symbol
+        recommendations = ticker.recommendations
+        if recommendations.empty:
+            return None, 0  # No recommendations available
+
+        # Assuming 'period' column exists and needs to be excluded
+        row_0 = recommendations.iloc[0, 1:]  # Exclude 'period' column if necessary
+
+        # Find the maximum voting result
+        max_votes = row_0.max()
+        majority_voting_result = row_0[row_0 == max_votes].index.tolist()
+
+        return majority_voting_result[0], max_votes
+
+
+if __name__ == "__main__":
+    print(YFinanceUtils.get_stock_data("AAPL", "2021-01-01", "2021-12-31"))
+    # print(YFinanceUtils.get_stock_data())

finrobot/functional/__init__.py

@@ -0,0 +1,6 @@
+from .analyzer import ReportAnalysisUtils
+from .charting import MplFinanceUtils, ReportChartUtils
+from .coding import CodingUtils, IPythonUtils
+from .quantitative import BackTraderUtils
+from .reportlab import ReportLabUtils
+from .text import TextUtils

finrobot/functional/analyzer.py

@@ -0,0 +1,344 @@
+import os
+from textwrap import dedent
+from typing import Annotated
+from datetime import timedelta, datetime
+from ..data_source import YFinanceUtils, SECUtils, FMPUtils
+
+
+def combine_prompt(instruction, resource, table_str=None):
+    if table_str:
+        prompt = f"{table_str}\n\nResource: {resource}\n\nInstruction: {instruction}"
+    else:
+        prompt = f"Resource: {resource}\n\nInstruction: {instruction}"
+    return prompt
+
+
+def save_to_file(data: str, file_path: str):
+    os.makedirs(os.path.dirname(file_path), exist_ok=True)
+    with open(file_path, "w") as f:
+        f.write(data)
+
+
+class ReportAnalysisUtils:
+
+    def analyze_income_stmt(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        fyear: Annotated[str, "fiscal year of the 10-K report"],
+        save_path: Annotated[str, "txt file path, to which the returned instruction & resources are written."]
+    ) -> str:
+        """
+        Retrieve the income statement for the given ticker symbol with the related section of its 10-K report.
+        Then return with an instruction on how to analyze the income statement.
+        """
+        # Retrieve the income statement
+        income_stmt = YFinanceUtils.get_income_stmt(ticker_symbol)
+        df_string = "Income statement:\n" + income_stmt.to_string().strip()
+
+        # Analysis instruction
+        instruction = dedent(
+            """
+            Conduct a comprehensive analysis of the company's income statement for the current fiscal year. 
+            Start with an overall revenue record, including Year-over-Year or Quarter-over-Quarter comparisons, 
+            and break down revenue sources to identify primary contributors and trends. Examine the Cost of 
+            Goods Sold for potential cost control issues. Review profit margins such as gross, operating, 
+            and net profit margins to evaluate cost efficiency, operational effectiveness, and overall profitability. 
+            Analyze Earnings Per Share to understand investor perspectives. Compare these metrics with historical 
+            data and industry or competitor benchmarks to identify growth patterns, profitability trends, and 
+            operational challenges. The output should be a strategic overview of the company’s financial health 
+            in a single paragraph, less than 130 words, summarizing the previous analysis into 4-5 key points under 
+            respective subheadings with specific discussion and strong data support.
+            """
+        )
+
+        # Retrieve the related section from the 10-K report
+        section_text = SECUtils.get_10k_section(ticker_symbol, fyear, 7)
+
+        # Combine the instruction, section text, and income statement
+        prompt = combine_prompt(instruction, section_text, df_string)
+
+        save_to_file(prompt, save_path)
+        return f"instruction & resources saved to {save_path}"
+
+    def analyze_balance_sheet(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        fyear: Annotated[str, "fiscal year of the 10-K report"],
+        save_path: Annotated[str, "txt file path, to which the returned instruction & resources are written."]
+    ) -> str:
+        """
+        Retrieve the balance sheet for the given ticker symbol with the related section of its 10-K report.
+        Then return with an instruction on how to analyze the balance sheet.
+        """
+        balance_sheet = YFinanceUtils.get_balance_sheet(ticker_symbol)
+        df_string = "Balance sheet:\n" + balance_sheet.to_string().strip()
+
+        instruction = dedent(
+            """
+            Delve into a detailed scrutiny of the company's balance sheet for the most recent fiscal year, pinpointing 
+            the structure of assets, liabilities, and shareholders' equity to decode the firm's financial stability and 
+            operational efficiency. Focus on evaluating the liquidity through current assets versus current liabilities, 
+            the solvency via long-term debt ratios, and the equity position to gauge long-term investment potential. 
+            Contrast these metrics with previous years' data to highlight financial trends, improvements, or deteriorations. 
+            Finalize with a strategic assessment of the company's financial leverage, asset management, and capital structure, 
+            providing insights into its fiscal health and future prospects in a single paragraph. Less than 130 words.
+            """
+        )
+
+        section_text = SECUtils.get_10k_section(ticker_symbol, fyear, 7)
+        prompt = combine_prompt(instruction, section_text, df_string)
+        save_to_file(prompt, save_path)
+        return f"instruction & resources saved to {save_path}"
+
+    def analyze_cash_flow(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        fyear: Annotated[str, "fiscal year of the 10-K report"],
+        save_path: Annotated[str, "txt file path, to which the returned instruction & resources are written."]
+    ) -> str:
+        """
+        Retrieve the cash flow statement for the given ticker symbol with the related section of its 10-K report.
+        Then return with an instruction on how to analyze the cash flow statement.
+        """
+        cash_flow = YFinanceUtils.get_cash_flow(ticker_symbol)
+        df_string = "Cash flow statement:\n" + cash_flow.to_string().strip()
+
+        instruction = dedent(
+            """
+            Dive into a comprehensive evaluation of the company's cash flow for the latest fiscal year, focusing on cash inflows 
+            and outflows across operating, investing, and financing activities. Examine the operational cash flow to assess the 
+            core business profitability, scrutinize investing activities for insights into capital expenditures and investments, 
+            and review financing activities to understand debt, equity movements, and dividend policies. Compare these cash movements 
+            to prior periods to discern trends, sustainability, and liquidity risks. Conclude with an informed analysis of the company's 
+            cash management effectiveness, liquidity position, and potential for future growth or financial challenges in a single paragraph. 
+            Less than 130 words.
+            """
+        )
+
+        section_text = SECUtils.get_10k_section(ticker_symbol, fyear, 7)
+        prompt = combine_prompt(instruction, section_text, df_string)
+        save_to_file(prompt, save_path)
+        return f"instruction & resources saved to {save_path}"
+
+    def analyze_segment_stmt(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        fyear: Annotated[str, "fiscal year of the 10-K report"],
+        save_path: Annotated[str, "txt file path, to which the returned instruction & resources are written."]
+    ) -> str:
+        """
+        Retrieve the income statement and the related section of its 10-K report for the given ticker symbol.
+        Then return with an instruction on how to create a segment analysis.
+        """
+        income_stmt = YFinanceUtils.get_income_stmt(ticker_symbol)
+        df_string = (
+            "Income statement (Segment Analysis):\n" + income_stmt.to_string().strip()
+        )
+
+        instruction = dedent(
+            """
+            Identify the company's business segments and create a segment analysis using the Management's Discussion and Analysis 
+            and the income statement, subdivided by segment with clear headings. Address revenue and net profit with specific data, 
+            and calculate the changes. Detail strategic partnerships and their impacts, including details like the companies or organizations. 
+            Describe product innovations and their effects on income growth. Quantify market share and its changes, or state market position 
+            and its changes. Analyze market dynamics and profit challenges, noting any effects from national policy changes. Include the cost side, 
+            detailing operational costs, innovation investments, and expenses from channel expansion, etc. Support each statement with evidence, 
+            keeping each segment analysis concise and under 60 words, accurately sourcing information. For each segment, consolidate the most 
+            significant findings into one clear, concise paragraph, excluding less critical or vaguely described aspects to ensure clarity and 
+            reliance on evidence-backed information. For each segment, the output should be one single paragraph within 150 words.
+            """
+        )
+        section_text = SECUtils.get_10k_section(ticker_symbol, fyear, 7)
+        prompt = combine_prompt(instruction, section_text, df_string)
+        save_to_file(prompt, save_path)
+        return f"instruction & resources saved to {save_path}"
+
+    def income_summarization(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        fyear: Annotated[str, "fiscal year of the 10-K report"],
+        income_stmt_analysis: Annotated[str, "in-depth income statement analysis"],
+        segment_analysis: Annotated[str, "in-depth segment analysis"],
+        save_path: Annotated[str, "txt file path, to which the returned instruction & resources are written."]
+    ) -> str:
+        """
+        With the income statement and segment analysis for the given ticker symbol.
+        Then return with an instruction on how to synthesize these analyses into a single coherent paragraph.
+        """
+        # income_stmt_analysis = analyze_income_stmt(ticker_symbol)
+        # segment_analysis = analyze_segment_stmt(ticker_symbol)
+
+        instruction = dedent(
+            f"""
+            Income statement analysis: {income_stmt_analysis},
+            Segment analysis: {segment_analysis},
+            Synthesize the findings from the in-depth income statement analysis and segment analysis into a single, coherent paragraph. 
+            It should be fact-based and data-driven. First, present and assess overall revenue and profit situation, noting significant 
+            trends and changes. Second, examine the performance of the various business segments, with an emphasis on their revenue and 
+            profit changes, revenue contributions and market dynamics. For information not covered in the first two areas, identify and 
+            integrate key findings related to operation, potential risks and strategic opportunities for growth and stability into the analysis. 
+            For each part, integrate historical data comparisons and provide relevant facts, metrics or data as evidence. The entire synthesis 
+            should be presented as a continuous paragraph without the use of bullet points. Use subtitles and numbering for each key point. 
+            The total output should be less than 160 words.
+            """
+        )
+
+        section_text = SECUtils.get_10k_section(ticker_symbol, fyear, 7)
+        prompt = combine_prompt(instruction, section_text, "")
+        save_to_file(prompt, save_path)
+        return f"instruction & resources saved to {save_path}"
+
+    def get_risk_assessment(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        fyear: Annotated[str, "fiscal year of the 10-K report"],
+        save_path: Annotated[str, "txt file path, to which the returned instruction & resources are written."]
+    ) -> str:
+        """
+        Retrieve the risk factors for the given ticker symbol with the related section of its 10-K report.
+        Then return with an instruction on how to summarize the top 3 key risks of the company.
+        """
+        company_name = YFinanceUtils.get_stock_info(ticker_symbol)["shortName"]
+        risk_factors = SECUtils.get_10k_section(ticker_symbol, fyear, "1A")
+        section_text = (
+            "Company Name: "
+            + company_name
+            + "\n\n"
+            + "Risk factors:\n"
+            + risk_factors
+            + "\n\n"
+        )
+        instruction = "According to the given information, summarize the top 3 key risks of the company. Less than 100 words."
+        prompt = combine_prompt(instruction, section_text, "")
+        save_to_file(prompt, save_path)
+        return f"instruction & resources saved to {save_path}"
+
+    def analyze_business_highlights(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        fyear: Annotated[str, "fiscal year of the 10-K report"],
+        save_path: Annotated[str, "txt file path, to which the returned instruction & resources are written."]
+    ) -> str:
+        """
+        Retrieve the business summary and related section of its 10-K report for the given ticker symbol.
+        Then return with an instruction on how to describe the performance highlights per business of the company.
+        """
+        business_summary = SECUtils.get_10k_section(ticker_symbol, fyear, 1)
+        section_7 = SECUtils.get_10k_section(ticker_symbol, fyear, 7)
+        section_text = (
+            "Business summary:\n"
+            + business_summary
+            + "\n\n"
+            + "Management's Discussion and Analysis of Financial Condition and Results of Operations:\n"
+            + section_7
+        )
+        instruction = dedent(
+            """
+            According to the given information, describe the performance highlights per business of the company. 
+            Each business description should contain one sentence of a summarization and one sentence of explanation. 
+            Less than 130 words.
+            """
+        )
+        prompt = combine_prompt(instruction, section_text, "")
+        save_to_file(prompt, save_path)
+        return f"instruction & resources saved to {save_path}"
+
+    def analyze_company_description(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        fyear: Annotated[str, "fiscal year of the 10-K report"],
+        save_path: Annotated[str, "txt file path, to which the returned instruction & resources are written."]
+    ) -> str:
+        """
+        Retrieve the company description and related sections of its 10-K report for the given ticker symbol.
+        Then return with an instruction on how to describe the company's industry, strengths, trends, and strategic initiatives.
+        """
+        company_name = YFinanceUtils.get_stock_info(ticker_symbol).get(
+            "shortName", "N/A"
+        )
+        business_summary = SECUtils.get_10k_section(ticker_symbol, fyear, 1)
+        section_7 = SECUtils.get_10k_section(ticker_symbol, fyear, 7)
+        section_text = (
+            "Company Name: "
+            + company_name
+            + "\n\n"
+            + "Business summary:\n"
+            + business_summary
+            + "\n\n"
+            + "Management's Discussion and Analysis of Financial Condition and Results of Operations:\n"
+            + section_7
+        )
+        instruction = dedent(
+            """
+            According to the given information, 
+            1. Briefly describe the company’s industry,
+            2. Highlight core strengths and competitive advantages key products or services,
+            3. Identify current industry trends, opportunities, and challenges that influence the company’s strategy,
+            4. Outline recent strategic initiatives such as product launches, acquisitions, or new partnerships, and describe the company's response to market conditions. 
+            Less than 400 words.
+            """
+        )
+        step_prompt = combine_prompt(instruction, section_text, "")
+        instruction2 = "Summarize the analysis, less than 130 words."
+        prompt = combine_prompt(instruction=instruction2, resource=step_prompt)
+        save_to_file(prompt, save_path)
+        return f"instruction & resources saved to {save_path}"
+
+    def get_key_data(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        filing_date: Annotated[
+            str | datetime, "the filing date of the financial report being analyzed"
+        ],
+    ) -> dict:
+        """
+        return key financial data used in annual report for the given ticker symbol and filing date
+        """
+
+        if not isinstance(filing_date, datetime):
+            filing_date = datetime.strptime(filing_date, "%Y-%m-%d")
+
+        # Fetch historical market data for the past 6 months
+        start = (filing_date - timedelta(weeks=52)).strftime("%Y-%m-%d")
+        end = filing_date.strftime("%Y-%m-%d")
+
+        hist = YFinanceUtils.get_stock_data(ticker_symbol, start, end)
+
+        # 获取其他相关信息
+        info = YFinanceUtils.get_stock_info(ticker_symbol)
+        close_price = hist["Close"].iloc[-1]
+
+        # Calculate the average daily trading volume
+        six_months_start = (filing_date - timedelta(weeks=26)).strftime("%Y-%m-%d")
+        hist_last_6_months = hist[
+            (hist.index >= six_months_start) & (hist.index <= end)
+        ]
+
+        # 计算这6个月的平均每日交易量
+        avg_daily_volume_6m = (
+            hist_last_6_months["Volume"].mean()
+            if not hist_last_6_months["Volume"].empty
+            else 0
+        )
+
+        fiftyTwoWeekLow = hist["High"].min()
+        fiftyTwoWeekHigh = hist["Low"].max()
+
+        # avg_daily_volume_6m = hist['Volume'].mean()
+
+        # convert back to str for function calling
+        filing_date = filing_date.strftime("%Y-%m-%d")
+
+        # Print the result
+        # print(f"Over the past 6 months, the average daily trading volume for {ticker_symbol} was: {avg_daily_volume_6m:.2f}")
+        rating, _ = YFinanceUtils.get_analyst_recommendations(ticker_symbol)
+        target_price = FMPUtils.get_target_price(ticker_symbol, filing_date)
+        result = {
+            "Rating": rating,
+            "Target Price": target_price,
+            f"6m avg daily vol ({info['currency']}mn)": "{:.2f}".format(
+                avg_daily_volume_6m / 1e6
+            ),
+            f"Closing Price ({info['currency']})": "{:.2f}".format(close_price),
+            f"Market Cap ({info['currency']}mn)": "{:.2f}".format(
+                FMPUtils.get_historical_market_cap(ticker_symbol, filing_date) / 1e6
+            ),
+            f"52 Week Price Range ({info['currency']})": "{:.2f} - {:.2f}".format(
+                fiftyTwoWeekLow, fiftyTwoWeekHigh
+            ),
+            f"BVPS ({info['currency']})": "{:.2f}".format(
+                FMPUtils.get_historical_bvps(ticker_symbol, filing_date)
+            ),
+        }
+        return result

finrobot/functional/charting.py

@@ -0,0 +1,235 @@
+import os
+import mplfinance as mpf
+import pandas as pd
+
+from matplotlib import pyplot as plt
+from typing import Annotated, List, Tuple
+from pandas import DateOffset
+from datetime import datetime, timedelta
+
+from ..data_source.yfinance_utils import YFinanceUtils
+
+
+class MplFinanceUtils:
+
+    def plot_stock_price_chart(
+        ticker_symbol: Annotated[
+            str, "Ticker symbol of the stock (e.g., 'AAPL' for Apple)"
+        ],
+        start_date: Annotated[
+            str, "Start date of the historical data in 'YYYY-MM-DD' format"
+        ],
+        end_date: Annotated[
+            str, "End date of the historical data in 'YYYY-MM-DD' format"
+        ],
+        save_path: Annotated[str, "File path where the plot should be saved"],
+        verbose: Annotated[
+            str, "Whether to print stock data to console. Default to False."
+        ] = False,
+        type: Annotated[
+            str,
+            "Type of the plot, should be one of 'candle','ohlc','line','renko','pnf','hollow_and_filled'. Default to 'candle'",
+        ] = "candle",
+        style: Annotated[
+            str,
+            "Style of the plot, should be one of 'default','classic','charles','yahoo','nightclouds','sas','blueskies','mike'. Default to 'default'.",
+        ] = "default",
+        mav: Annotated[
+            int | List[int] | Tuple[int, ...] | None,
+            "Moving average window(s) to plot on the chart. Default to None.",
+        ] = None,
+        show_nontrading: Annotated[
+            bool, "Whether to show non-trading days on the chart. Default to False."
+        ] = False,
+    ) -> str:
+        """
+        Plot a stock price chart using mplfinance for the specified stock and time period,
+        and save the plot to a file.
+        """
+        # Fetch historical data
+        stock_data = YFinanceUtils.get_stock_data(ticker_symbol, start_date, end_date)
+        if verbose:
+            print(stock_data.to_string())
+
+        params = {
+            "type": type,
+            "style": style,
+            "title": f"{ticker_symbol} {type} chart",
+            "ylabel": "Price",
+            "volume": True,
+            "ylabel_lower": "Volume",
+            "mav": mav,
+            "show_nontrading": show_nontrading,
+            "savefig": save_path,
+        }
+        # Using dictionary comprehension to filter out None values (MplFinance does not accept None values)
+        filtered_params = {k: v for k, v in params.items() if v is not None}
+
+        # Plot chart
+        mpf.plot(stock_data, **filtered_params)
+
+        return f"{type} chart saved to <img {save_path}>"
+
+
+class ReportChartUtils:
+
+    def get_share_performance(
+        ticker_symbol: Annotated[
+            str, "Ticker symbol of the stock (e.g., 'AAPL' for Apple)"
+        ],
+        filing_date: Annotated[str | datetime, "filing date in 'YYYY-MM-DD' format"],
+        save_path: Annotated[str, "File path where the plot should be saved"],
+    ) -> str:
+        """Plot the stock performance of a company compared to the S&P 500 over the past year."""
+        if isinstance(filing_date, str):
+            filing_date = datetime.strptime(filing_date, "%Y-%m-%d")
+
+        def fetch_stock_data(ticker):
+            start = (filing_date - timedelta(days=365)).strftime("%Y-%m-%d")
+            end = filing_date.strftime("%Y-%m-%d")
+            historical_data = YFinanceUtils.get_stock_data(ticker, start, end)
+            # hist = stock.history(period=period)
+            return historical_data["Close"]
+
+        target_close = fetch_stock_data(ticker_symbol)
+        sp500_close = fetch_stock_data("^GSPC")
+        info = YFinanceUtils.get_stock_info(ticker_symbol)
+
+        # 计算变化率
+        company_change = (
+            (target_close - target_close.iloc[0]) / target_close.iloc[0] * 100
+        )
+        sp500_change = (sp500_close - sp500_close.iloc[0]) / sp500_close.iloc[0] * 100
+
+        # 计算额外的日期点
+        start_date = company_change.index.min()
+        four_months = start_date + DateOffset(months=4)
+        eight_months = start_date + DateOffset(months=8)
+        end_date = company_change.index.max()
+
+        # 准备绘图
+        plt.rcParams.update({"font.size": 20})  # 调整为更大的字体大小
+        plt.figure(figsize=(14, 7))
+        plt.plot(
+            company_change.index,
+            company_change,
+            label=f'{info["shortName"]} Change %',
+            color="blue",
+        )
+        plt.plot(
+            sp500_change.index, sp500_change, label="S&P 500 Change %", color="red"
+        )
+
+        # 设置标题和标签
+        plt.title(f'{info["shortName"]} vs S&P 500 - Change % Over the Past Year')
+        plt.xlabel("Date")
+        plt.ylabel("Change %")
+
+        # 设置x轴刻度标签
+        plt.xticks(
+            [start_date, four_months, eight_months, end_date],
+            [
+                start_date.strftime("%Y-%m"),
+                four_months.strftime("%Y-%m"),
+                eight_months.strftime("%Y-%m"),
+                end_date.strftime("%Y-%m"),
+            ],
+        )
+
+        plt.legend()
+        plt.grid(True)
+        plt.tight_layout()
+        # plt.show()
+        plot_path = (
+            f"{save_path}/stock_performance.png"
+            if os.path.isdir(save_path)
+            else save_path
+        )
+        plt.savefig(plot_path)
+        plt.close()
+        return f"last year stock performance chart saved to <img {plot_path}>"
+
+    def get_pe_eps_performance(
+        ticker_symbol: Annotated[
+            str, "Ticker symbol of the stock (e.g., 'AAPL' for Apple)"
+        ],
+        filing_date: Annotated[str | datetime, "filing date in 'YYYY-MM-DD' format"],
+        years: Annotated[int, "number of years to search from, default to 4"] = 4,
+        save_path: Annotated[str, "File path where the plot should be saved"] = None,
+    ) -> str:
+        """Plot the PE ratio and EPS performance of a company over the past n years."""
+        if isinstance(filing_date, str):
+            filing_date = datetime.strptime(filing_date, "%Y-%m-%d")
+
+        ss = YFinanceUtils.get_income_stmt(ticker_symbol)
+        eps = ss.loc["Diluted EPS", :]
+
+        # 获取过去5年的历史数据
+        # historical_data = self.stock.history(period="5y")
+        days = round((years + 1) * 365.25)
+        start = (filing_date - timedelta(days=days)).strftime("%Y-%m-%d")
+        end = filing_date.strftime("%Y-%m-%d")
+        historical_data = YFinanceUtils.get_stock_data(ticker_symbol, start, end)
+
+        # 指定的日期，并确保它们都是UTC时区的
+        dates = pd.to_datetime(eps.index[::-1], utc=True)
+
+        # 为了确保我们能够找到最接近的股市交易日，我们将转换日期并查找最接近的日期
+        results = {}
+        for date in dates:
+            # 如果指定日期不是交易日，使用bfill和ffill找到最近的交易日股价
+            if date not in historical_data.index:
+                close_price = historical_data.asof(date)
+            else:
+                close_price = historical_data.loc[date]
+
+            results[date] = close_price["Close"]
+
+        pe = [p / e for p, e in zip(results.values(), eps.values[::-1])]
+        dates = eps.index[::-1]
+        eps = eps.values[::-1]
+
+        info = YFinanceUtils.get_stock_info(ticker_symbol)
+
+        # 创建图形和轴对象
+        fig, ax1 = plt.subplots(figsize=(14, 7))
+        plt.rcParams.update({"font.size": 20})  # 调整为更大的字体大小
+
+        # 绘制市盈率
+        color = "tab:blue"
+        ax1.set_xlabel("Date")
+        ax1.set_ylabel("PE Ratio", color=color)
+        ax1.plot(dates, pe, color=color)
+        ax1.tick_params(axis="y", labelcolor=color)
+        ax1.grid(True)
+
+        # 创建与ax1共享x轴的第二个轴对象
+        ax2 = ax1.twinx()
+        color = "tab:red"
+        ax2.set_ylabel("EPS", color=color)  # 第二个y轴的标签
+        ax2.plot(dates, eps, color=color)
+        ax2.tick_params(axis="y", labelcolor=color)
+
+        # 设置标题和x轴标签角度
+        plt.title(f'{info["shortName"]} PE Ratios and EPS Over the Past {years} Years')
+        plt.xticks(rotation=45)
+
+        # 设置x轴刻度标签
+        plt.xticks(dates, [d.strftime("%Y-%m") for d in dates])
+
+        plt.tight_layout()
+        # plt.show()
+        plot_path = (
+            f"{save_path}/pe_performance.png" if os.path.isdir(save_path) else save_path
+        )
+        plt.savefig(plot_path)
+        plt.close()
+        return f"pe performance chart saved to <img {plot_path}>"
+
+
+if __name__ == "__main__":
+    # Example usage:
+    start_date = "2024-03-01"
+    end_date = "2024-04-01"
+    save_path = "AAPL_candlestick_chart.png"
+    MplFinanceUtils.plot_candlestick_chart("AAPL", start_date, end_date, save_path)

finrobot/functional/coding.py

@@ -0,0 +1,89 @@
+import os
+from typing_extensions import Annotated
+from IPython import get_ipython
+
+default_path = "coding/"
+
+
+class IPythonUtils:
+
+    def exec_python(cell: Annotated[str, "Valid Python cell to execute."]) -> str:
+        """
+        run cell in ipython and return the execution result.
+        """
+        ipython = get_ipython()
+        result = ipython.run_cell(cell)
+        log = str(result.result)
+        if result.error_before_exec is not None:
+            log += f"\n{result.error_before_exec}"
+        if result.error_in_exec is not None:
+            log += f"\n{result.error_in_exec}"
+        return log
+
+    def display_image(
+        image_path: Annotated[str, "Path to image file to display."]
+    ) -> str:
+        """
+        Display image in Jupyter Notebook.
+        """
+        log = __class__.exec_python(
+            f"from IPython.display import Image, display\n\ndisplay(Image(filename='{image_path}'))"
+        )
+        if not log:
+            return "Image displayed successfully"
+        else:
+            return log
+
+
+class CodingUtils:  # Borrowed from https://microsoft.github.io/autogen/docs/notebooks/agentchat_function_call_code_writing
+
+    def list_dir(directory: Annotated[str, "Directory to check."]) -> str:
+        """
+        List files in choosen directory.
+        """
+        files = os.listdir(default_path + directory)
+        return str(files)
+
+    def see_file(filename: Annotated[str, "Name and path of file to check."]) -> str:
+        """
+        Check the contents of a chosen file.
+        """
+        with open(default_path + filename, "r") as file:
+            lines = file.readlines()
+        formatted_lines = [f"{i+1}:{line}" for i, line in enumerate(lines)]
+        file_contents = "".join(formatted_lines)
+
+        return file_contents
+
+    def modify_code(
+        filename: Annotated[str, "Name and path of file to change."],
+        start_line: Annotated[int, "Start line number to replace with new code."],
+        end_line: Annotated[int, "End line number to replace with new code."],
+        new_code: Annotated[
+            str,
+            "New piece of code to replace old code with. Remember about providing indents.",
+        ],
+    ) -> str:
+        """
+        Replace old piece of code with new one. Proper indentation is important.
+        """
+        with open(default_path + filename, "r+") as file:
+            file_contents = file.readlines()
+            file_contents[start_line - 1 : end_line] = [new_code + "\n"]
+            file.seek(0)
+            file.truncate()
+            file.write("".join(file_contents))
+        return "Code modified"
+
+    def create_file_with_code(
+        filename: Annotated[str, "Name and path of file to create."],
+        code: Annotated[str, "Code to write in the file."],
+    ) -> str:
+        """
+        Create a new file with provided code.
+        """
+        directory = os.path.dirname(default_path + filename)
+        os.makedirs(directory, exist_ok=True)
+        with open(default_path + filename, "w") as file:
+            file.write(code)
+        return "File created successfully"

finrobot/functional/quantitative.py

@@ -0,0 +1,184 @@
+import os
+import json
+import importlib
+import yfinance as yf
+import backtrader as bt
+from backtrader.strategies import SMA_CrossOver
+from typing import Annotated, List, Tuple
+from matplotlib import pyplot as plt
+from pprint import pformat
+from IPython import get_ipython
+
+
+class DeployedCapitalAnalyzer(bt.Analyzer):
+    def start(self):
+        self.deployed_capital = []
+        self.initial_cash = self.strategy.broker.get_cash()  # Initial cash in account
+
+    def notify_order(self, order):
+        if order.status in [order.Completed]:
+            if order.isbuy():
+                self.deployed_capital.append(order.executed.price * order.executed.size)
+            elif order.issell():
+                self.deployed_capital.append(order.executed.price * order.executed.size)
+
+    def stop(self):
+        total_deployed = sum(self.deployed_capital)
+        final_cash = self.strategy.broker.get_value()
+        net_profit = final_cash - self.initial_cash
+        if total_deployed > 0:
+            self.retn = net_profit / total_deployed
+        else:
+            self.retn = 0
+
+    def get_analysis(self):
+        return {"return_on_deployed_capital": self.retn}
+
+
+class BackTraderUtils:
+
+    def back_test(
+        ticker_symbol: Annotated[
+            str, "Ticker symbol of the stock (e.g., 'AAPL' for Apple)"
+        ],
+        start_date: Annotated[
+            str, "Start date of the historical data in 'YYYY-MM-DD' format"
+        ],
+        end_date: Annotated[
+            str, "End date of the historical data in 'YYYY-MM-DD' format"
+        ],
+        strategy: Annotated[
+            str,
+            "BackTrader Strategy class to be backtested. Can be pre-defined or custom. Pre-defined options: 'SMA_CrossOver'. If custom, provide module path and class name as a string like 'my_module:TestStrategy'.",
+        ],
+        strategy_params: Annotated[
+            str,
+            "Additional parameters to be passed to the strategy class formatted as json string. E.g. {'fast': 10, 'slow': 30} for SMACross.",
+        ] = "",
+        sizer: Annotated[
+            int | str | None,
+            "Sizer used for backtesting. Can be a fixed number or a custom Sizer class. If input is integer, a corresponding fixed sizer will be applied. If custom, provide module path and class name as a string like 'my_module:TestSizer'.",
+        ] = None,
+        sizer_params: Annotated[
+            str,
+            "Additional parameters to be passed to the sizer class formatted as json string.",
+        ] = "",
+        indicator: Annotated[
+            str | None,
+            "Custom indicator class added to strategy. Provide module path and class name as a string like 'my_module:TestIndicator'.",
+        ] = None,
+        indicator_params: Annotated[
+            str,
+            "Additional parameters to be passed to the indicator class formatted as json string.",
+        ] = "",
+        cash: Annotated[
+            float, "Initial cash amount for the backtest. Default to 10000.0"
+        ] = 10000.0,
+        save_fig: Annotated[
+            str | None, "Path to save the plot of backtest results. Default to None."
+        ] = None,
+    ) -> str:
+        """
+        Use the Backtrader library to backtest a trading strategy on historical stock data.
+        """
+        cerebro = bt.Cerebro()
+
+        if strategy == "SMA_CrossOver":
+            strategy_class = SMA_CrossOver
+        else:
+            assert (
+                ":" in strategy
+            ), "Custom strategy should be module path and class name separated by a colon."
+            module_path, class_name = strategy.split(":")
+            module = importlib.import_module(module_path)
+            strategy_class = getattr(module, class_name)
+
+        strategy_params = json.loads(strategy_params) if strategy_params else {}
+        cerebro.addstrategy(strategy_class, **strategy_params)
+
+        # Create a data feed
+        data = bt.feeds.PandasData(
+            dataname=yf.download(ticker_symbol, start_date, end_date, auto_adjust=True)
+        )
+        cerebro.adddata(data)  # Add the data feed
+        # Set our desired cash start
+        cerebro.broker.setcash(cash)
+
+        # Set the size of the trades
+        if sizer is not None:
+            if isinstance(sizer, int):
+                cerebro.addsizer(bt.sizers.FixedSize, stake=sizer)
+            else:
+                assert (
+                    ":" in sizer
+                ), "Custom sizer should be module path and class name separated by a colon."
+                module_path, class_name = sizer.split(":")
+                module = importlib.import_module(module_path)
+                sizer_class = getattr(module, class_name)
+                sizer_params = json.loads(sizer_params) if sizer_params else {}
+                cerebro.addsizer(sizer_class, **sizer_params)
+
+        # Set additional indicator
+        if indicator is not None:
+            assert (
+                ":" in indicator
+            ), "Custom indicator should be module path and class name separated by a colon."
+            module_path, class_name = indicator.split(":")
+            module = importlib.import_module(module_path)
+            indicator_class = getattr(module, class_name)
+            indicator_params = json.loads(indicator_params) if indicator_params else {}
+            cerebro.addindicator(indicator_class, **indicator_params)
+
+        # Attach analyzers
+        cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name="sharpe_ratio")
+        cerebro.addanalyzer(bt.analyzers.DrawDown, _name="draw_down")
+        cerebro.addanalyzer(bt.analyzers.Returns, _name="returns")
+        cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name="trade_analyzer")
+        # cerebro.addanalyzer(DeployedCapitalAnalyzer, _name="deployed_capital")
+
+        stats_dict = {"Starting Portfolio Value:": cerebro.broker.getvalue()}
+
+        results = cerebro.run()  # run it all
+        first_strategy = results[0]
+
+        # Access analysis results
+        stats_dict["Final Portfolio Value"] = cerebro.broker.getvalue()
+        # stats_dict["Deployed Capital"] = pformat(
+        #     first_strategy.analyzers.deployed_capital.get_analysis(), indent=4
+        # )
+        stats_dict["Sharpe Ratio"] = (
+            first_strategy.analyzers.sharpe_ratio.get_analysis()
+        )
+        stats_dict["Drawdown"] = first_strategy.analyzers.draw_down.get_analysis()
+        stats_dict["Returns"] = first_strategy.analyzers.returns.get_analysis()
+        stats_dict["Trade Analysis"] = (
+            first_strategy.analyzers.trade_analyzer.get_analysis()
+        )
+
+        if save_fig:
+            directory = os.path.dirname(save_fig)
+            if directory:
+                os.makedirs(directory, exist_ok=True)
+            plt.figure(figsize=(12, 8))
+            cerebro.plot()
+            plt.savefig(save_fig)
+            plt.close()
+
+        return "Back Test Finished. Results: \n" + pformat(stats_dict, indent=2)
+
+
+if __name__ == "__main__":
+    # Example usage:
+    start_date = "2011-01-01"
+    end_date = "2012-12-31"
+    ticker = "MSFT"
+    # BackTraderUtils.back_test(
+    #     ticker, start_date, end_date, "SMA_CrossOver", {"fast": 10, "slow": 30}
+    # )
+    BackTraderUtils.back_test(
+        ticker,
+        start_date,
+        end_date,
+        "test_module:TestStrategy",
+        {"exitbars": 5},
+    )

finrobot/functional/reportlab.py

@@ -0,0 +1,391 @@
+import os
+import traceback
+from reportlab.lib import colors
+from reportlab.lib import pagesizes
+from reportlab.platypus import (
+    SimpleDocTemplate,
+    Frame,
+    Paragraph,
+    Image,
+    PageTemplate,
+    FrameBreak,
+    Spacer,
+    Table,
+    TableStyle,
+    NextPageTemplate,
+    PageBreak,
+)
+from reportlab.lib.units import inch
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY, TA_LEFT
+
+from ..data_source import FMPUtils, YFinanceUtils
+from .analyzer import ReportAnalysisUtils
+from typing import Annotated
+
+
+class ReportLabUtils:
+
+    def build_annual_report(
+        ticker_symbol: Annotated[str, "ticker symbol"],
+        save_path: Annotated[str, "path to save the annual report pdf"],
+        income_summarization: Annotated[
+            str,
+            "a paragraph of text: the company's income summarization from its financial report",
+        ],
+        business_highlights: Annotated[
+            str,
+            "a paragraph of text: the company's business highlights from its financial report",
+        ],
+        company_description: Annotated[
+            str,
+            "a paragraph of text: the company's description and current situation from its financial report",
+        ],
+        risk_assessment: Annotated[
+            str,
+            "a paragraph of text: the company's risk assessment from its financial report",
+        ],
+        share_performance_image_path: Annotated[
+            str, "path to the share performance image"
+        ],
+        pe_eps_performance_image_path: Annotated[
+            str, "path to the PE and EPS performance image"
+        ],
+        filing_date: Annotated[str, "filing date of the analyzed financial report"],
+    ) -> str:
+        """
+        Aggregate a company's income summarization, business highlights, company description,
+        risk assessment and share performance, PE & EPS performance charts all into a PDF report.
+        """
+        try:
+            # 2. 创建PDF并插入图像
+            # 页面设置
+            page_width, page_height = pagesizes.A4
+            left_column_width = page_width * 2 / 3
+            right_column_width = page_width - left_column_width
+            margin = 4
+
+            # 创建PDF文档路径
+            pdf_path = (
+                os.path.join(save_path, f"{ticker_symbol}_report.pdf")
+                if os.path.isdir(save_path)
+                else save_path
+            )
+            os.makedirs(os.path.dirname(pdf_path), exist_ok=True)
+            doc = SimpleDocTemplate(pdf_path, pagesize=pagesizes.A4)
+
+            # 定义两个栏位的Frame
+            frame_left = Frame(
+                margin,
+                margin,
+                left_column_width - margin * 2,
+                page_height - margin * 2,
+                id="left",
+            )
+            frame_right = Frame(
+                left_column_width,
+                margin,
+                right_column_width - margin * 2,
+                page_height - margin * 2,
+                id="right",
+            )
+
+            # single_frame = Frame(margin, margin, page_width-margin*2, page_height-margin*2, id='single')
+            # single_column_layout = PageTemplate(id='OneCol', frames=[single_frame])
+
+            left_column_width_p2 = (page_width - margin * 3) // 2
+            right_column_width_p2 = left_column_width_p2
+            frame_left_p2 = Frame(
+                margin,
+                margin,
+                left_column_width_p2 - margin * 2,
+                page_height - margin * 2,
+                id="left",
+            )
+            frame_right_p2 = Frame(
+                left_column_width_p2,
+                margin,
+                right_column_width_p2 - margin * 2,
+                page_height - margin * 2,
+                id="right",
+            )
+
+            # 创建PageTemplate，并添加到文档
+            page_template = PageTemplate(
+                id="TwoColumns", frames=[frame_left, frame_right]
+            )
+            page_template_p2 = PageTemplate(
+                id="TwoColumns_p2", frames=[frame_left_p2, frame_right_p2]
+            )
+
+            # Define single column Frame
+            single_frame = Frame(
+                margin,
+                margin,
+                page_width - 2 * margin,
+                page_height - 2 * margin,
+                id="single",
+            )
+
+            # Create a PageTemplate with a single column
+            single_column_layout = PageTemplate(id="OneCol", frames=[single_frame])
+
+            doc.addPageTemplates(
+                [page_template, single_column_layout, page_template_p2]
+            )
+
+            styles = getSampleStyleSheet()
+
+            # 自定义样式
+            custom_style = ParagraphStyle(
+                name="Custom",
+                parent=styles["Normal"],
+                fontName="Helvetica",
+                fontSize=10,
+                # leading=15,
+                alignment=TA_JUSTIFY,
+            )
+
+            title_style = ParagraphStyle(
+                name="TitleCustom",
+                parent=styles["Title"],
+                fontName="Helvetica-Bold",
+                fontSize=16,
+                leading=20,
+                alignment=TA_LEFT,
+                spaceAfter=10,
+            )
+
+            subtitle_style = ParagraphStyle(
+                name="Subtitle",
+                parent=styles["Heading2"],
+                fontName="Helvetica-Bold",
+                fontSize=14,
+                leading=12,
+                alignment=TA_LEFT,
+                spaceAfter=6,
+            )
+
+            table_style2 = TableStyle(
+                [
+                    ("BACKGROUND", (0, 0), (-1, -1), colors.white),
+                    ("BACKGROUND", (0, 0), (-1, 0), colors.white),
+                    ("FONT", (0, 0), (-1, -1), "Helvetica", 7),
+                    ("FONT", (0, 0), (-1, 0), "Helvetica-Bold", 14),
+                    ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
+                    # 所有单元格左对齐
+                    ("ALIGN", (0, 0), (-1, -1), "LEFT"),
+                    # 标题栏下方添加横线
+                    ("LINEBELOW", (0, 0), (-1, 0), 2, colors.black),
+                    # 表格最下方添加横线
+                    ("LINEBELOW", (0, -1), (-1, -1), 2, colors.black),
+                ]
+            )
+
+            name = YFinanceUtils.get_stock_info(ticker_symbol)["shortName"]
+
+            # 准备左栏和右栏内容
+            content = []
+            # 标题
+            content.append(
+                Paragraph(
+                    f"Equity Research Report: {name}",
+                    title_style,
+                )
+            )
+
+            # 子标题
+            content.append(Paragraph("Income Summarization", subtitle_style))
+            content.append(Paragraph(income_summarization, custom_style))
+
+            content.append(Paragraph("Business Highlights", subtitle_style))
+            content.append(Paragraph(business_highlights, custom_style))
+
+            content.append(Paragraph("Company Situation", subtitle_style))
+            content.append(Paragraph(company_description, custom_style))
+
+            content.append(Paragraph("Risk Assessment", subtitle_style))
+            content.append(Paragraph(risk_assessment, custom_style))
+
+            # content.append(Paragraph("Summarization", subtitle_style))
+            df = FMPUtils.get_financial_metrics(ticker_symbol, years=5)
+            df.reset_index(inplace=True)
+            currency = YFinanceUtils.get_stock_info(ticker_symbol)["currency"]
+            df.rename(columns={"index": f"FY ({currency} mn)"}, inplace=True)
+            table_data = [["Financial Metrics"]]
+            table_data += [df.columns.to_list()] + df.values.tolist()
+
+            col_widths = [(left_column_width - margin * 4) / df.shape[1]] * df.shape[1]
+            table = Table(table_data, colWidths=col_widths)
+            table.setStyle(table_style2)
+            content.append(table)
+
+            content.append(FrameBreak())  # 用于从左栏跳到右栏
+
+            table_style = TableStyle(
+                [
+                    ("BACKGROUND", (0, 0), (-1, -1), colors.white),
+                    ("BACKGROUND", (0, 0), (-1, 0), colors.white),
+                    ("FONT", (0, 0), (-1, -1), "Helvetica", 8),
+                    ("FONT", (0, 0), (-1, 0), "Helvetica-Bold", 12),
+                    ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
+                    # 第一列左对齐
+                    ("ALIGN", (0, 1), (0, -1), "LEFT"),
+                    # 第二列右对齐
+                    ("ALIGN", (1, 1), (1, -1), "RIGHT"),
+                    # 标题栏下方添加横线
+                    ("LINEBELOW", (0, 0), (-1, 0), 2, colors.black),
+                ]
+            )
+            full_length = right_column_width - 2 * margin
+
+            data = [
+                ["FinRobot"],
+                ["https://ai4finance.org/"],
+                ["https://github.com/AI4Finance-Foundation/FinRobot"],
+                [f"Report date: {filing_date}"],
+            ]
+            col_widths = [full_length]
+            table = Table(data, colWidths=col_widths)
+            table.setStyle(table_style)
+            content.append(table)
+
+            # content.append(Paragraph("", custom_style))
+            content.append(Spacer(1, 0.15 * inch))
+            key_data = ReportAnalysisUtils.get_key_data(ticker_symbol, filing_date)
+            # 表格数据
+            data = [["Key data", ""]]
+            data += [[k, v] for k, v in key_data.items()]
+            col_widths = [full_length // 3 * 2, full_length // 3]
+            table = Table(data, colWidths=col_widths)
+            table.setStyle(table_style)
+            content.append(table)
+
+            # 将Matplotlib图像添加到右栏
+
+            # 历史股价
+            data = [["Share Performance"]]
+            col_widths = [full_length]
+            table = Table(data, colWidths=col_widths)
+            table.setStyle(table_style)
+            content.append(table)
+
+            plot_path = share_performance_image_path
+            width = right_column_width
+            height = width // 2
+            content.append(Image(plot_path, width=width, height=height))
+
+            # 历史PE和EPS
+            data = [["PE & EPS"]]
+            col_widths = [full_length]
+            table = Table(data, colWidths=col_widths)
+            table.setStyle(table_style)
+            content.append(table)
+
+            plot_path = pe_eps_performance_image_path
+            width = right_column_width
+            height = width // 2
+            content.append(Image(plot_path, width=width, height=height))
+
+            # # 开始新的一页
+            # content.append(NextPageTemplate("OneCol"))
+            # content.append(PageBreak())
+
+            # def add_table(df, title):
+            #     df = df.applymap(lambda x: "{:.2f}".format(x) if isinstance(x, float) else x)
+            #     # df.columns = [col.strftime('%Y') for col in df.columns]
+            #     # df.reset_index(inplace=True)
+            #     # currency = ra.info['currency']
+            #     df.rename(columns={"index": "segment"}, inplace=True)
+            #     table_data = [[title]]
+            #     table_data += [df.columns.to_list()] + df.values.tolist()
+
+            #     table = Table(table_data)
+            #     table.setStyle(table_style2)
+            #     num_columns = len(df.columns)
+
+            #     column_width = (page_width - 4 * margin) / (num_columns + 1)
+            #     first_column_witdh = column_width * 2
+            #     table._argW = [first_column_witdh] + [column_width] * (num_columns - 1)
+
+            #     content.append(table)
+            #     content.append(Spacer(1, 0.15 * inch))
+
+            # if os.path.exists(f"{ra.project_dir}/outer_resource/"):
+            #     Revenue10Q = pd.read_csv(
+            #         f"{ra.project_dir}/outer_resource/Revenue10Q.csv",
+            #     )
+            #     # del Revenue10K['FY2018']
+            #     # del Revenue10K['FY2019']
+            #     add_table(Revenue10Q, "Revenue")
+
+            #     Ratio10Q = pd.read_csv(
+            #         f"{ra.project_dir}/outer_resource/Ratio10Q.csv",
+            #     )
+            #     # del Ratio10K['FY2018']
+            #     # del Ratio10K['FY2019']
+            #     add_table(Ratio10Q, "Ratio")
+
+            #     Yoy10Q = pd.read_csv(
+            #         f"{ra.project_dir}/outer_resource/Yoy10Q.csv",
+            #     )
+            #     # del Yoy10K['FY2018']
+            #     # del Yoy10K['FY2019']
+            #     add_table(Yoy10Q, "Yoy")
+
+            #     plot_path = os.path.join(f"{ra.project_dir}/outer_resource/", "segment.png")
+            #     width = page_width - 2 * margin
+            #     height = width * 3 // 5
+            #     content.append(Image(plot_path, width=width, height=height))
+
+            # # 第二页及之后内容，使用单栏布局
+            # df = ra.get_income_stmt()
+            # df = df[df.columns[:3]]
+            # def convert_if_money(value):
+            #     if np.abs(value) >= 1000000:
+            #         return value / 1000000
+            #     else:
+            #         return value
+
+            # # 应用转换函数到DataFrame的每列
+            # df = df.applymap(convert_if_money)
+
+            # df.columns = [col.strftime('%Y') for col in df.columns]
+            # df.reset_index(inplace=True)
+            # currency = ra.info['currency']
+            # df.rename(columns={'index': f'FY ({currency} mn)'}, inplace=True)  # 可选：重命名索引列为“序号”
+            # table_data = [["Income Statement"]]
+            # table_data += [df.columns.to_list()] + df.values.tolist()
+
+            # table = Table(table_data)
+            # table.setStyle(table_style2)
+            # content.append(table)
+
+            # content.append(FrameBreak())  # 用于从左栏跳到右栏
+
+            # df = ra.get_cash_flow()
+            # df = df[df.columns[:3]]
+
+            # df = df.applymap(convert_if_money)
+
+            # df.columns = [col.strftime('%Y') for col in df.columns]
+            # df.reset_index(inplace=True)
+            # currency = ra.info['currency']
+            # df.rename(columns={'index': f'FY ({currency} mn)'}, inplace=True)  # 可选：重命名索引列为“序号”
+            # table_data = [["Cash Flow Sheet"]]
+            # table_data += [df.columns.to_list()] + df.values.tolist()
+
+            # table = Table(table_data)
+            # table.setStyle(table_style2)
+            # content.append(table)
+            # # content.append(Paragraph('This is a single column on the second page', custom_style))
+            # # content.append(Spacer(1, 0.2*inch))
+            # # content.append(Paragraph('More content in the single column.', custom_style))
+
+            # 构建PDF文档
+            doc.build(content)
+
+            return "Annual report generated successfully."
+
+        except Exception:
+            return traceback.format_exc()

finrobot/functional/text.py

@@ -0,0 +1,19 @@
+from typing import Annotated
+
+class TextUtils:
+
+    def check_text_length(
+        text: Annotated[str, "text to check"],
+        min_length: Annotated[int, "minimum length of the text, default to 0"] = 0,
+        max_length: Annotated[int, "maximum length of the text, default to 100000"] = 100000,
+    ) -> str:
+        """
+        Check if the length of the text is exceeds than the maximum length.
+        """
+        length = len(text.split())
+        if length > max_length:
+            return f"Text length {length} exceeds the maximum length of {max_length}."
+        elif length < min_length:
+            return f"Text length {length} is less than the minimum length of {min_length}."
+        else:
+            return f"Text length {length} is within the expected range."

finrobot/toolkits.py

@@ -0,0 +1,106 @@
+from autogen import register_function, ConversableAgent
+from .data_source import *
+from .functional.coding import CodingUtils
+
+from typing import List, Callable
+from functools import wraps
+from pandas import DataFrame
+
+
+def stringify_output(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        result = func(*args, **kwargs)
+        if isinstance(result, DataFrame):
+            return result.to_string()
+        else:
+            return str(result)
+
+    return wrapper
+
+
+def register_toolkits(
+    config: List[dict | Callable | type],
+    caller: ConversableAgent,
+    executor: ConversableAgent,
+    **kwargs
+):
+    """Register tools from a configuration list."""
+
+    for tool in config:
+
+        if isinstance(tool, type):
+            register_tookits_from_cls(caller, executor, tool, **kwargs)
+            continue
+
+        tool_dict = {"function": tool} if callable(tool) else tool
+        if "function" not in tool_dict or not callable(tool_dict["function"]):
+            raise ValueError(
+                "Function not found in tool configuration or not callable."
+            )
+
+        tool_function = tool_dict["function"]
+        name = tool_dict.get("name", tool_function.__name__)
+        description = tool_dict.get("description", tool_function.__doc__)
+        register_function(
+            stringify_output(tool_function),
+            caller=caller,
+            executor=executor,
+            name=name,
+            description=description,
+        )
+
+
+def register_code_writing(caller: ConversableAgent, executor: ConversableAgent):
+    """Register code writing tools."""
+
+    register_toolkits(
+        [
+            {
+                "function": CodingUtils.list_dir,
+                "name": "list_files",
+                "description": "List files in a directory.",
+            },
+            {
+                "function": CodingUtils.see_file,
+                "name": "see_file",
+                "description": "Check the contents of a chosen file.",
+            },
+            {
+                "function": CodingUtils.modify_code,
+                "name": "modify_code",
+                "description": "Replace old piece of code with new one.",
+            },
+            {
+                "function": CodingUtils.create_file_with_code,
+                "name": "create_file_with_code",
+                "description": "Create a new file with provided code.",
+            },
+        ],
+        caller,
+        executor,
+    )
+
+
+def register_tookits_from_cls(
+    caller: ConversableAgent,
+    executor: ConversableAgent,
+    cls: type,
+    include_private: bool = False,
+):
+    """Register all methods of a class as tools."""
+    if include_private:
+        funcs = [
+            func
+            for func in dir(cls)
+            if callable(getattr(cls, func)) and not func.startswith("__")
+        ]
+    else:
+        funcs = [
+            func
+            for func in dir(cls)
+            if callable(getattr(cls, func))
+            and not func.startswith("__")
+            and not func.startswith("_")
+        ]
+    register_toolkits([getattr(cls, func) for func in funcs], caller, executor)

finrobot/utils.py

@@ -0,0 +1,83 @@
+import os
+import json
+import pandas as pd
+from datetime import date, timedelta, datetime
+from typing import Annotated
+
+
+# Define custom annotated types
+# VerboseType = Annotated[bool, "Whether to print data to console. Default to True."]
+SavePathType = Annotated[str, "File path to save data. If None, data is not saved."]
+
+
+# def process_output(data: pd.DataFrame, tag: str, verbose: VerboseType = True, save_path: SavePathType = None) -> None:
+#     if verbose:
+#         print(data.to_string())
+#     if save_path:
+#         data.to_csv(save_path)
+#         print(f"{tag} saved to {save_path}")
+
+
+def save_output(data: pd.DataFrame, tag: str, save_path: SavePathType = None) -> None:
+    if save_path:
+        data.to_csv(save_path)
+        print(f"{tag} saved to {save_path}")
+
+
+def get_current_date():
+    return date.today().strftime("%Y-%m-%d")
+
+
+def register_keys_from_json(file_path):
+    with open(file_path, "r") as f:
+        keys = json.load(f)
+    for key, value in keys.items():
+        os.environ[key] = value
+
+
+def decorate_all_methods(decorator):
+    def class_decorator(cls):
+        for attr_name, attr_value in cls.__dict__.items():
+            if callable(attr_value):
+                setattr(cls, attr_name, decorator(attr_value))
+        return cls
+
+    return class_decorator
+
+
+def get_next_weekday(date):
+
+    if not isinstance(date, datetime):
+        date = datetime.strptime(date, "%Y-%m-%d")
+
+    if date.weekday() >= 5:
+        days_to_add = 7 - date.weekday()
+        next_weekday = date + timedelta(days=days_to_add)
+        return next_weekday
+    else:
+        return date
+
+
+# def create_inner_assistant(
+#         name, system_message, llm_config, max_round=10,
+#         code_execution_config=None
+#     ):
+
+#     inner_assistant = autogen.AssistantAgent(
+#         name=name,
+#         system_message=system_message + "Reply TERMINATE when the task is done.",
+#         llm_config=llm_config,
+#         is_termination_msg=lambda x: x.get("content", "").find("TERMINATE") >= 0,
+#     )
+#     executor = autogen.UserProxyAgent(
+#         name=f"{name}-executor",
+#         human_input_mode="NEVER",
+#         code_execution_config=code_execution_config,
+#         default_auto_reply="",
+#         is_termination_msg=lambda x: x.get("content", "").find("TERMINATE") >= 0,
+#     )
+#     assistant.register_nested_chats(
+#         [{"recipient": assistant, "message": reflection_message, "summary_method": "last_msg", "max_turns": 1}],
+#         trigger=ConversableAgent
+#         )
+#     return manager

requirements.txt

@@ -0,0 +1,21 @@
+finrobot
+pyautogen>=0.2.19
+ipython
+huggingface_hub
+matplotlib
+python-dotenv
+gradio
+finnhub-python
+yfinance
+mplfinance
+backtrader
+sec_api
+numpy
+pandas
+pyPDF2
+reportlab
+pyautogen[retrievechat]
+setuptools>=41.4.0
+wheel>=0.33.6
+tushare
+pandas_datareader

serveren.py

@@ -0,0 +1,199 @@
+import os
+import json
+import pandas as pd
+from datetime import date
+import gradio as gr
+import autogen
+from autogen.cache import Cache
+from finrobot.utils import get_current_date
+from finrobot.data_source import FinnHubUtils, YFinanceUtils
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Utility functions
+def save_output(data: pd.DataFrame, tag: str, save_path: str = None) -> None:
+    if save_path:
+        data.to_csv(save_path)
+        print(f"{tag} saved to {save_path}")
+
+def get_current_date():
+    return date.today().strftime("%Y-%m-%d")
+
+def register_keys():
+    keys = {
+        "FINNHUB_API_KEY": os.getenv("FINNHUB_API_KEY"),
+        "FMP_API_KEY": os.getenv("FMP_API_KEY"),
+        "SEC_API_KEY": os.getenv("SEC_API_KEY")
+    }
+    for key, value in keys.items():
+        if value:
+            os.environ[key] = value
+
+def read_response_from_md(filename):
+    with open(filename, "r") as file:
+        content = file.read()
+    return content
+
+def save_to_md(content, filename):
+    with open(filename, "w") as file:  # Use write mode to overwrite the file
+        file.write(content + "\n")
+    print(f"Content saved to {filename}")
+
+# Initialize LLM configuration
+config_list = [
+    {
+        "model": "gpt-4o",
+        "api_key": os.getenv("OPENAI_API_KEY")
+    }
+]
+llm_config = {"config_list": config_list, "timeout": 120, "temperature": 0}
+
+# Register FINNHUB API keys
+register_keys()
+
+# Define agents
+analyst = autogen.AssistantAgent(
+    name="Market_Analyst",
+    system_message="As a Market Analyst, one must possess strong analytical and problem-solving abilities, collect necessary financial information and aggregate them based on client's requirement. For coding tasks, only use the functions you have been provided with. Reply TERMINATE when the task is done.",
+    llm_config=llm_config,
+)
+
+user_proxy = autogen.UserProxyAgent(
+    name="User_Proxy",
+    is_termination_msg=lambda x: x.get("content", "") and x.get("content", "").strip().endswith("TERMINATE"),
+    human_input_mode="NEVER",
+    max_consecutive_auto_reply=10,
+    code_execution_config={
+        "work_dir": "coding",
+        "use_docker": False,
+    },
+)
+
+# Register tools
+from finrobot.toolkits import register_toolkits
+
+tools = [
+    {
+        "function": FinnHubUtils.get_company_profile,
+        "name": "get_company_profile",
+        "description": "get a company's profile information"
+    },
+    {
+        "function": FinnHubUtils.get_company_news,
+        "name": "get_company_news",
+        "description": "retrieve market news related to designated company"
+    },
+    {
+        "function": FinnHubUtils.get_basic_financials,
+        "name": "get_financial_basics",
+        "description": "get latest financial basics for a designated company"
+    },
+    {
+        "function": YFinanceUtils.get_stock_data,
+        "name": "get_stock_data",
+        "description": "retrieve stock price data for designated ticker symbol"
+    }
+]
+register_toolkits(tools, analyst, user_proxy)
+
+def save_response_to_json(response, filename):
+    response_dict = {
+        "chat_id": response.chat_id,
+        "chat_history": response.chat_history,
+        "summary": response.summary,
+        "cost": response.cost,
+        "human_input": response.human_input
+    }
+    with open(filename, "w") as file:
+        file.write(json.dumps(response_dict, indent=4))
+    print(f"Response saved to {filename}")
+
+# Function to initiate chat and save response
+def initiate_chat_and_save_response(analyst, user_proxy, company):
+    today_date = get_current_date()
+    json_filename = f"result_{company}_{today_date}.json"
+    md_filename = f"result_{company}_{today_date}.md"
+    
+    # Check if MD file already exists
+    if os.path.exists(md_filename):
+        return read_response_from_md(md_filename)
+    
+    with Cache.disk() as cache:
+        response = user_proxy.initiate_chat(
+            analyst,
+            message=f"Use all the tools provided to retrieve information available for {company} upon {get_current_date()}. Analyze the positive developments and potential concerns of {company} with 2-4 most important factors respectively and keep them concise. Most factors should be inferred from company related news. Then make a rough prediction (e.g. up/down by %) of the {company} stock price movement for next week. Provide a summary analysis to support your prediction.",
+            cache=cache,
+        )
+        
+        save_response_to_json(response, json_filename)
+        return json.dumps(response.chat_history, indent=4)
+
+def filter_user_content(chat_history):
+    # 解析 chat_history 为 JSON 对象
+    chat_history_dict = json.loads(chat_history)
+    # 查找用户需要的内容
+    for entry in chat_history_dict:
+        if entry['role'] == 'user' and "###" in entry['content']:
+            return entry['content']
+    return "No relevant content found."
+
+# 使用更新的函数在 analyze_company 中
+def analyze_company(company):
+    if company:
+        company = company.upper()
+        today_date = get_current_date()
+        md_filename = f"result_{company}_{today_date}.md"
+        
+        # Check if MD file already exists
+        if os.path.exists(md_filename):
+            return read_response_from_md(md_filename)
+        
+        content = initiate_chat_and_save_response(analyst, user_proxy, company)
+        # 筛选有效的用户内容
+        filtered_content = filter_user_content(content)
+        save_to_md(filtered_content, md_filename)  # 只保存筛选后的内容
+        return filtered_content
+
+# 自定义CSS样式
+custom_css = """
+h1, h2, h3, h4, h5, h6 {
+    font-family: 'Arial', sans-serif;
+    font-weight: bold;
+}
+body {
+    font-family: 'Arial', sans-serif;
+}
+.gradio-container {
+    max-width: 800px;
+    margin: auto;
+    padding: 20px;
+    border: 1px solid #ccc;
+    border-radius: 10px;
+    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+}
+textarea, input, .btn-primary {
+    font-size: 16px !important;
+    padding: 10px !important;
+    border-radius: 5px !important;
+}
+#component-0 > .wrap > .block.markdown-block > .markdown {
+    font-size: 24px !important;
+    line-height: 1.8 !important;
+}
+"""
+
+# Gradio接口
+iface = gr.Interface(
+    fn=analyze_company,
+    inputs=gr.Textbox(lines=1, placeholder="Enter company name or stock code"),
+    outputs=gr.Markdown(label="Trade-Helper"),
+    title="Trade-Helper",
+    description="Enter the company name or stock code to get a AI-Powered analysis and forcast prediction.",
+    css=custom_css,
+    allow_flagging='never'
+)
+
+if __name__ == "__main__":
+    iface.launch(share=True)

setup.py

@@ -0,0 +1,41 @@
+from setuptools import setup, find_packages
+
+# Read requirements.txt, ignore comments
+try:
+    with open("requirements.txt", "r") as f:
+        REQUIRES = [line.split("#", 1)[0].strip() for line in f if line.strip()]
+except:
+    print("'requirements.txt' not found!")
+    REQUIRES = list()
+
+setup(
+    name="FinRobot",
+    version="0.1.3",
+    include_package_data=True,
+    author="AI4Finance Foundation",
+    author_email="[email protected]",
+    url="https://github.com/AI4Finance-Foundation/FinRobot",
+    license="MIT",
+    packages=find_packages(),
+    install_requires=REQUIRES,
+    description="FinRobot: An Open-Source AI Agent Platform for Financial Applications using LLMs",
+    long_description="""FinRobot""",
+    classifiers=[
+        # Trove classifiers
+        # Full list: https://pypi.python.org/pypi?%3Aaction=list_classifiers
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: Implementation :: CPython",
+        "Programming Language :: Python :: Implementation :: PyPy",
+    ],
+    keywords="Financial Large Language Models, AI Agents",
+    platforms=["any"],
+    python_requires=">=3.10, <3.12",
+)

test_module.py

@@ -0,0 +1,89 @@
+import backtrader as bt
+
+
+# Create a Stratey
+class TestStrategy(bt.Strategy):
+    params = (("exitbars", 5),)
+
+    def log(self, txt, dt=None):
+        """Logging function fot this strategy"""
+        dt = dt or self.datas[0].datetime.date(0)
+        print("%s, %s" % (dt.isoformat(), txt))
+
+    def __init__(self):
+        # Keep a reference to the "close" line in the data[0] dataseries
+        self.dataclose = self.datas[0].close
+
+        # To keep track of pending orders and buy price/commission
+        self.order = None
+        self.buyprice = None
+        self.buycomm = None
+
+    def notify_order(self, order):
+        if order.status in [order.Submitted, order.Accepted]:
+            # Buy/Sell order submitted/accepted to/by broker - Nothing to do
+            return
+
+        # Check if an order has been completed
+        # Attention: broker could reject order if not enough cash
+        if order.status in [order.Completed]:
+            if order.isbuy():
+                self.log(
+                    "BUY EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f"
+                    % (order.executed.price, order.executed.value, order.executed.comm)
+                )
+
+                self.buyprice = order.executed.price
+                self.buycomm = order.executed.comm
+            else:  # Sell
+                self.log(
+                    "SELL EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f"
+                    % (order.executed.price, order.executed.value, order.executed.comm)
+                )
+
+            self.bar_executed = len(self)
+
+        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
+            self.log("Order Canceled/Margin/Rejected")
+
+        self.order = None
+
+    def notify_trade(self, trade):
+        if not trade.isclosed:
+            return
+
+        self.log("OPERATION PROFIT, GROSS %.2f, NET %.2f" % (trade.pnl, trade.pnlcomm))
+
+    def next(self):
+        # Simply log the closing price of the series from the reference
+        self.log("Close, %.2f" % self.dataclose[0])
+
+        # Check if an order is pending ... if yes, we cannot send a 2nd one
+        if self.order:
+            return
+
+        # Check if we are in the market
+        if not self.position:
+
+            # Not yet ... we MIGHT BUY if ...
+            if self.dataclose[0] < self.dataclose[-1]:
+                # current close less than previous close
+
+                if self.dataclose[-1] < self.dataclose[-2]:
+                    # previous close less than the previous close
+
+                    # BUY, BUY, BUY!!! (with default parameters)
+                    self.log("BUY CREATE, %.2f" % self.dataclose[0])
+
+                    # Keep track of the created order to avoid a 2nd order
+                    self.order = self.buy()
+
+        else:
+
+            # Already in the market ... we might sell
+            if len(self) >= (self.bar_executed + self.params.exitbars):
+                # SELL, SELL, SELL!!! (with all possible default parameters)
+                self.log("SELL CREATE, %.2f" % self.dataclose[0])
+
+                # Keep track of the created order to avoid a 2nd order
+                self.order = self.sell()