Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,18 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+SETUP-PC.pdf filter=lfs diff=lfs merge=lfs -text
+SETUP-linux.pdf filter=lfs diff=lfs merge=lfs -text
+SETUP-mac.pdf filter=lfs diff=lfs merge=lfs -text
+business.jpg filter=lfs diff=lfs merge=lfs -text
+important.jpg filter=lfs diff=lfs merge=lfs -text
+resources.jpg filter=lfs diff=lfs merge=lfs -text
+thankyou.jpg filter=lfs diff=lfs merge=lfs -text
+voyage.jpg filter=lfs diff=lfs merge=lfs -text
+week2/community-contributions/chatbot_conversation_robots.jpg filter=lfs diff=lfs merge=lfs -text
+week4/community-contributions/ai_code_converter/screenshots/codeXchange_3.png filter=lfs diff=lfs merge=lfs -text
+week5/community-contributions/docuSeekAI/docuseek2.png filter=lfs diff=lfs merge=lfs -text
+week5/community-contributions/docuSeekAI/docuseek3.png filter=lfs diff=lfs merge=lfs -text
+week5/community-contributions/docuSeekAI/docuseek4.png filter=lfs diff=lfs merge=lfs -text
+week8/community_contributions/images/gui.png filter=lfs diff=lfs merge=lfs -text
+week8/community_contributions/images/metrics.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,184 @@
+# Github's default gitignore for Python
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+llms/
+llms.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+.idea/
+
+# Added this to ignore models downloaded from HF
+model_cache/
+# Ignore finder files
+.DS_Store
+/.DS_Store
+
+# Ignore Chroma vector database
+vector_db/
+products_vectorstore/
+
+# And ignore any pickle files made during the course
+*.pkl
+
+# ignore gradio private files
+.gradio
+/.gradio
+
+# ignore diagnostics reports
+**/report.txt
+
+# ignore optimized C++ code from being checked into repo
+week4/optimized
+week4/simple

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ed Donner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,130 @@
 ---
-title: Llm Engineering
-emoji: 😻
-colorFrom: purple
-colorTo: red
+title: llm_engineering
+app_file: turo_assist.py
 sdk: gradio
 sdk_version: 5.29.0
-app_file: app.py
-pinned: false
 ---
+# LLM Engineering - Master AI and LLMs
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Your 8 week journey to proficiency starts today
+
+![Voyage](voyage.jpg)
+
+I'm so happy you're joining me on this path. We'll be building immensely satisfying projects in the coming weeks. Some will be easy, some will be challenging, many will ASTOUND you! The projects build on each other so you develop deeper and deeper expertise each week. One thing's for sure: you're going to have a lot of fun along the way.
+
+### Before you begin
+
+I'm here to help you be most successful with your learning! If you hit any snafus, or if you have any ideas on how I can improve the course, please do reach out in the platform or by emailing me direct ([email protected]). It's always great to connect with people on LinkedIn to build up the community - you'll find me here:  
+https://www.linkedin.com/in/eddonner/  
+And this is new to me, but I'm also trying out X/Twitter at [@edwarddonner](https://x.com/edwarddonner) - if you're on X, please show me how it's done 😂  
+
+Resources to accompany the course, including the slides and useful links, are here:  
+https://edwarddonner.com/2024/11/13/llm-engineering-resources/
+
+## Instant Gratification instructions for Week 1, Day 1 - with Llama 3.2 **not** Llama 3.3!
+
+### Important note: see my warning about Llama3.3 below - it's too large for home computers! Stick with llama3.2! Several students have missed this warning...
+
+We will start the course by installing Ollama so you can see results immediately!
+1. Download and install Ollama from https://ollama.com noting that on a PC you might need to have administrator permissions for the install to work properly
+2. On a PC, start a Command prompt / Powershell (Press Win + R, type `cmd`, and press Enter). On a Mac, start a Terminal (Applications > Utilities > Terminal).
+3. Run `ollama run llama3.2` or for smaller machines try `ollama run llama3.2:1b` - **please note** steer clear of Meta's latest model llama3.3 because at 70B parameters that's way too large for most home computers!  
+4. If this doesn't work: you may need to run `ollama serve` in another Powershell (Windows) or Terminal (Mac), and try step 3 again. On a PC, you may need to be running in an Admin instance of Powershell.  
+5. And if that doesn't work on your box, I've set up this on the cloud. This is on Google Colab, which will need you to have a Google account to sign in, but is free:  https://colab.research.google.com/drive/1-_f5XZPsChvfU1sJ0QqCePtIuc55LSdu?usp=sharing
+
+Any problems, please contact me!
+
+## Then, Setup instructions
+
+After we do the Ollama quick project, and after I introduce myself and the course, we get to work with the full environment setup.  
+
+Hopefully I've done a decent job of making these guides bulletproof - but please contact me right away if you hit roadblocks:
+
+- PC people please follow the instructions in [SETUP-PC.md](SETUP-PC.md)
+- Mac people please follow the instructions in [SETUP-mac.md](SETUP-mac.md)  
+- Linux people please follow the instructions in [SETUP-linux.md](SETUP-linux.md)
+
+The are also PDF versions of the setup instructions in this folder if you'd prefer.
+
+### An important point on API costs (which are optional! No need to spend if you don't wish)
+
+During the course, I'll suggest you try out the leading models at the forefront of progress, known as the Frontier models. I'll also suggest you run open-source models using Google Colab. These services have some charges, but I'll keep cost minimal - like, a few cents at a time. And I'll provide alternatives if you'd prefer not to use them.
+
+Please do monitor your API usage to ensure you're comfortable with spend; I've included links below. There's no need to spend anything more than a couple of dollars for the entire course. Some AI providers such as OpenAI require a minimum credit like \$5 or local equivalent; we should only spend a fraction of it, and you'll have plenty of opportunity to put it to good use in your own projects. During Week 7 you have an option to spend a bit more if you're enjoying the process - I spend about \$10 myself and the results make me very happy indeed! But it's not necessary in the least; the important part is that you focus on learning.
+
+### Free alternative to Paid APIs
+
+Early in the course, I show you an alternative if you'd rather not spend anything on APIs:  
+Any time that we have code like:  
+`openai = OpenAI()`  
+You can use this as a direct replacement:  
+`openai = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')`  
+And also replace model names like **gpt-4o-mini** with **llama3.2**.  
+For week 1 day 1, you can find this in week1/solutions/day1_with_ollama.ipynb.
+
+Below is a full example:
+
+```
+# You need to do this one time on your computer
+!ollama pull llama3.2
+
+from openai import OpenAI
+MODEL = "llama3.2"
+openai = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
+
+response = openai.chat.completions.create(
+ model=MODEL,
+ messages=[{"role": "user", "content": "What is 2 + 2?"}]
+)
+
+print(response.choices[0].message.content)
+```
+
+### How this Repo is organized
+
+There are folders for each of the "weeks", representing modules of the class, culminating in a powerful autonomous Agentic AI solution in Week 8 that draws on many of the prior weeks.    
+Follow the setup instructions above, then open the Week 1 folder and prepare for joy.
+
+### The most important part
+
+The mantra of the course is: the best way to learn is by **DOING**. I don't type all the code during the course; I execute it for you to see the results. You should work along with me or after each lecture, running each cell, inspecting the objects to get a detailed understanding of what's happening. Then tweak the code and make it your own. There are juicy challenges for you throughout the course. I'd love it if you wanted to submit a Pull Request for your code (instructions [here](https://chatgpt.com/share/677a9cb5-c64c-8012-99e0-e06e88afd293)) and I can make your solutions available to others so we share in your progress; as an added benefit, you'll be recognized in GitHub for your contribution to the repo. While the projects are enjoyable, they are first and foremost designed to be _educational_, teaching you business skills that can be put into practice in your work.
+
+## Starting in Week 3, we'll also be using Google Colab for running with GPUs
+
+You should be able to use the free tier or minimal spend to complete all the projects in the class. I personally signed up for Colab Pro+ and I'm loving it - but it's not required.
+
+Learn about Google Colab and set up a Google account (if you don't already have one) [here](https://colab.research.google.com/)
+
+The colab links are in the Week folders and also here:  
+- For week 3 day 1, this Google Colab shows what [colab can do](https://colab.research.google.com/drive/1DjcrYDZldAXKJ08x1uYIVCtItoLPk1Wr?usp=sharing)
+- For week 3 day 2, here is a colab for the HuggingFace [pipelines API](https://colab.research.google.com/drive/1aMaEw8A56xs0bRM4lu8z7ou18jqyybGm?usp=sharing)
+- For week 3 day 3, here's the colab on [Tokenizers](https://colab.research.google.com/drive/1WD6Y2N7ctQi1X9wa6rpkg8UfyA4iSVuz?usp=sharing)
+- For week 3 day 4, we go to a colab with HuggingFace [models](https://colab.research.google.com/drive/1hhR9Z-yiqjUe7pJjVQw4c74z_V3VchLy?usp=sharing)
+- For week 3 day 5, we return to colab to make our [Meeting Minutes product](https://colab.research.google.com/drive/1KSMxOCprsl1QRpt_Rq0UqCAyMtPqDQYx?usp=sharing)
+- For week 7, we will use these Colab books: [Day 1](https://colab.research.google.com/drive/15rqdMTJwK76icPBxNoqhI7Ww8UM-Y7ni?usp=sharing) | [Day 2](https://colab.research.google.com/drive/1T72pbfZw32fq-clQEp-p8YQ4_qFKv4TP?usp=sharing) | [Days 3 and 4](https://colab.research.google.com/drive/1csEdaECRtjV_1p9zMkaKKjCpYnltlN3M?usp=sharing) | [Day 5](https://colab.research.google.com/drive/1igA0HF0gvQqbdBD4GkcK3GpHtuDLijYn?usp=sharing)
+
+### Monitoring API charges
+
+You can keep your API spend very low throughout this course; you can monitor spend at the dashboards: [here](https://platform.openai.com/usage) for OpenAI, [here](https://console.anthropic.com/settings/cost) for Anthropic and [here](https://console.cloud.google.com/apis/api/generativelanguage.googleapis.com/cost) for Google Gemini.
+
+The charges for the exercsies in this course should always be quite low, but if you'd prefer to keep them minimal, then be sure to always choose the cheapest versions of models:
+1. For OpenAI: Always use model `gpt-4o-mini` in the code instead of `gpt-4o`
+2. For Anthropic: Always use model `claude-3-haiku-20240307` in the code instead of the other Claude models
+3. During week 7, look out for my instructions for using the cheaper dataset
+
+Please do message me or email me at [email protected] if this doesn't work or if I can help with anything. I can't wait to hear how you get on.
+
+<table style="margin: 0; text-align: left;">
+    <tr>
+        <td style="width: 150px; height: 150px; vertical-align: middle;">
+            <img src="resources.jpg" width="150" height="150" style="display: block;" />
+        </td>
+        <td>
+            <h2 style="color:#f71;">Other resources</h2>
+            <span style="color:#f71;">I've put together this webpage with useful resources for the course. This includes links to all the slides.<br/>
+            <a href="https://edwarddonner.com/2024/11/13/llm-engineering-resources/">https://edwarddonner.com/2024/11/13/llm-engineering-resources/</a><br/>
+            Please keep this bookmarked, and I'll continue to add more useful links there over time.
+            </span>
+        </td>
+    </tr>
+</table>

SETUP-PC.md

@@ -0,0 +1,200 @@
+# LLM Engineering - Master AI and LLMs
+
+## Setup instructions for Windows
+
+Welcome, PC people!
+
+I should confess up-front: setting up a powerful environment to work at the forefront of AI is not as simple as I'd like. For most people these instructions will go great; but in some cases, for whatever reason, you'll hit a problem. Please don't hesitate to reach out - I am here to get you up and running quickly. There's nothing worse than feeling _stuck_. Message me, email me or LinkedIn message me and I will unstick you quickly!
+
+Email: [email protected]  
+LinkedIn: https://www.linkedin.com/in/eddonner/  
+
+I use a platform called Anaconda to set up your environment. It's a powerful tool that builds a complete science environment. Anaconda ensures that you're working with the right version of Python and all your packages are compatible with mine, even if our systems are completely different. It takes more time to set up, and it uses more hard drive space (5+ GB) but it's very reliable once its working.
+
+Having said that: if you have any problems with Anaconda, I've provided an alternative approach. It's faster and simpler and should have you running quickly, with less of a guarantee around compatibility.
+
+### Before we begin - Heads up! Please do check these Windows "gotchas":
+
+If you are relatively new to using the Command Prompt, here is an excellent [guide](https://chatgpt.com/share/67b0acea-ba38-8012-9c34-7a2541052665) with instructions and exercises. I'd suggest you work through this first to build some confidence.
+
+There are 4 common gotchas to developing on Windows to be aware of:   
+
+1. Permissions. Please take a look at this [tutorial](https://chatgpt.com/share/67b0ae58-d1a8-8012-82ca-74762b0408b0) on permissions on Windows  
+2. Anti-virus, Firewall, VPN. These can interfere with installations and network access; try temporarily disabling them as needed  
+3. The evil Windows 260 character limit to filenames - here is a full [explanation and fix](https://chatgpt.com/share/67b0afb9-1b60-8012-a9f7-f968a5a910c7)!  
+4. If you've not worked with Data Science packages on your computer before, you might need to install Microsoft Build Tools. Here are [instructions](https://chatgpt.com/share/67b0b762-327c-8012-b809-b4ec3b9e7be0). A student also mentioned that [these instructions](https://github.com/bycloudai/InstallVSBuildToolsWindows) might be helpful for people on Windows 11.    
+
+### Part 1: Clone the Repo
+
+This gets you a local copy of the code on your box.
+
+1. **Install Git** (if not already installed):
+
+- Download Git from https://git-scm.com/download/win
+- Run the installer and follow the prompts, using default options (press OK lots of times!). 
+- After the installation, you may need to open a new Powershell window to use it (or you might even need to restart)
+
+2. **Open Command Prompt:**
+
+- Press Win + R, type `cmd`, and press Enter
+
+3. **Navigate to your projects folder:**
+
+If you have a specific folder for projects, navigate to it using the cd command. For example:  
+`cd C:\Users\YourUsername\Documents\Projects`  
+Replacing YourUsername with your actual Windows user
+
+If you don't have a projects folder, you can create one:
+```
+mkdir C:\Users\YourUsername\Documents\Projects
+cd C:\Users\YourUsername\Documents\Projects
+```
+
+4. **Clone the repository:**
+
+Enter this in the command prompt in the Projects folder:
+
+`git clone https://github.com/ed-donner/llm_engineering.git`
+
+This creates a new directory `llm_engineering` within your Projects folder and downloads the code for the class. Do `cd llm_engineering` to go into it. This `llm_engineering` directory is known as the "project root directory".
+
+### Part 2: Install Anaconda environment
+
+If this Part 2 gives you any problems, there is an alternative Part 2B below that can be used instead.
+
+1. **Install Anaconda:**
+
+- Download Anaconda from https://docs.anaconda.com/anaconda/install/windows/
+- Run the installer and follow the prompts. Note that it takes up several GB and take a while to install, but it will be a powerful platform for you to use in the future.
+
+2. **Set up the environment:**
+
+- Open **Anaconda Prompt** (search for it in the Start menu)
+- Navigate to the "project root directory" by entering something like `cd C:\Users\YourUsername\Documents\Projects\llm_engineering` using the actual path to your llm_engineering project root directory. Do a `dir` and check you can see subdirectories for each week of the course.
+- Create the environment: `conda env create -f environment.yml`
+- **If you get an ArchiveError issue, then this is caused by the Windows 260 character limit - see gotcha number 3 at the top**
+- Wait for a few minutes for all packages to be installed - in some cases, this can literally take 30 minutes if you've not used Anaconda before, and even longer depending on your internet connection. Important stuff is happening! If this runs for more than 1 hour 15 mins, or gives you other problems, please go to Part 2B instead.  
+- You have now built an isolated, dedicated AI environment for engineering LLMs, running vector datastores, and so much more! You now need to **activate** it using this command: `conda activate llms`  
+
+You should see `(llms)` in your prompt, which indicates you've activated your new environment.
+
+3. **Start Jupyter Lab:**
+
+- In the Anaconda Prompt, from within the `llm_engineering` folder, type: `jupyter lab`
+
+...and Jupyter Lab should open up in a browser. If you've not seen Jupyter Lab before, I'll explain it in a moment! Now close the jupyter lab browser tab, and close the Anaconda prompt, and move on to Part 3.
+
+### Part 2B - Alternative to Part 2 if Anaconda gives you trouble
+
+1. **Open Command Prompt**
+
+Press Win + R, type `cmd`, and press Enter  
+
+Run `python --version` to find out which python you're on.  
+Ideally you'd be using a version of Python 3.11, so we're completely in sync.  
+I believe Python 3.12 works also, but (as of Feb 2025) Python 3.13 does **not** yet work as several Data Science dependencies are not yet ready for Python 3.13.  
+If you need to install Python or install another version, you can download it here:  
+https://www.python.org/downloads/
+
+2. Navigate to the "project root directory" by entering something like `cd C:\Users\YourUsername\Documents\Projects\llm_engineering` using the actual path to your llm_engineering project root directory. Do a `dir` and check you can see subdirectories for each week of the course.  
+
+Then, create a new virtual environment with this command:  
+`python -m venv llms`
+
+3. Activate the virtual environment with  
+`llms\Scripts\activate`
+You should see (llms) in your command prompt, which is your sign that things are going well.
+
+4. Run `python -m pip install --upgrade pip` followed by `pip install -r requirements.txt`  
+This may take a few minutes to install.  
+If you see an error like this:
+
+> Microsoft Visual C++ 14.0 or greater is required. Get it with "Microsoft C++ Build Tools": [https://visualstudio.microsoft.com/visual-cpp-build-tools/](https://visualstudio.microsoft.com/visual-cpp-build-tools/)
+
+Then please follow the link and install Microsoft C++ Build Tools. A student also mentioned that [these instructions](https://github.com/bycloudai/InstallVSBuildToolsWindows) might be helpful for people on Windows 11.   
+
+In the very unlikely event that this step doesn't go well, you should try the bullet-proof (but slower) version:  
+`pip install --retries 5 --timeout 15 --no-cache-dir --force-reinstall -r requirements.txt`
+
+6. **Start Jupyter Lab:**
+
+From within the `llm_engineering` folder, type: `jupyter lab`  
+...and Jupyter Lab should open up, ready for you to get started. Open the `week1` folder and double click on `day1.ipynb`. Success! Now close down jupyter lab and move on to Part 3.
+
+If there are any problems, contact me!
+
+### Part 3 - OpenAI key (OPTIONAL but recommended)
+
+Particularly during weeks 1 and 2 of the course, you'll be writing code to call the APIs of Frontier models (models at the forefront of AI).
+
+For week 1, you'll only need OpenAI, and you can add the others if you wish later on.
+
+1. Create an OpenAI account if you don't have one by visiting:  
+https://platform.openai.com/
+
+2. OpenAI asks for a minimum credit to use the API. For me in the US, it's \$5. The API calls will spend against this \$5. On this course, we'll only use a small portion of this. I do recommend you make the investment as you'll be able to put it to excellent use. But if you'd prefer not to pay for the API, I give you an alternative in the course using Ollama.
+
+You can add your credit balance to OpenAI at Settings > Billing:  
+https://platform.openai.com/settings/organization/billing/overview
+
+I recommend you disable the automatic recharge!
+
+3. Create your API key
+
+The webpage where you set up your OpenAI key is at https://platform.openai.com/api-keys - press the green 'Create new secret key' button and press 'Create secret key'. Keep a record of the API key somewhere private; you won't be able to retrieve it from the OpenAI screens in the future. It should start `sk-proj-`.
+
+In week 2 we will also set up keys for Anthropic and Google, which you can do here when we get there.  
+- Claude API at https://console.anthropic.com/ from Anthropic
+- Gemini API at https://ai.google.dev/gemini-api from Google
+
+Later in the course you'll be using the fabulous HuggingFace platform; an account is available for free at https://huggingface.co - you can create an API token from the Avatar menu >> Settings >> Access Tokens.
+
+And in Week 6/7 you'll be using the terrific Weights & Biases at https://wandb.ai to watch over your training batches. Accounts are also free, and you can set up a token in a similar way.
+
+### PART 4 - .env file
+
+When you have these keys, please create a new file called `.env` in your project root directory. The filename needs to be exactly the four characters ".env" rather than "my-keys.env" or ".env.txt". Here's how to do it:
+
+1. Open the Notepad (Windows + R to open the Run box, enter `notepad`)
+
+2. In the Notepad, type this, replacing xxxx with your API key (starting `sk-proj-`).
+
+```
+OPENAI_API_KEY=xxxx
+```
+
+If you have other keys, you can add them too, or come back to this in future weeks:  
+```
+GOOGLE_API_KEY=xxxx
+ANTHROPIC_API_KEY=xxxx
+DEEPSEEK_API_KEY=xxxx
+HF_TOKEN=xxxx
+```
+
+Double check there are no spaces before or after the `=` sign, and no spaces at the end of the key.
+
+3. Go to File > Save As. In the "Save as type" dropdown, select All Files. In the "File name" field, type exactly **.env** as the filename. Choose to save this in the project root directory (the folder called `llm_engineering`) and click Save.
+
+4. Navigate to the folder where you saved the file in Explorer and ensure it was saved as ".env" not ".env.txt" - if necessary rename it to ".env" -  you might need to ensure that "Show file extensions" is set to "On" so that you see the file extensions. Message or email me if that doesn't make sense!
+
+This file won't appear in Jupyter Lab because jupyter hides files starting with a dot. This file is listed in the `.gitignore` file, so it won't get checked in and your keys stay safe.
+
+### Part 5 - Showtime!!
+
+- Open **Anaconda Prompt** (search for it in the Start menu) if you used Anaconda, otherwise open a Powershell if you used the alternative approach in Part 2B
+  
+- Navigate to the "project root directory" by entering something like `cd C:\Users\YourUsername\Documents\Projects\llm_engineering` using the actual path to your llm_engineering project root directory. Do a `dir` and check you can see subdirectories for each week of the course.
+
+- Activate your environment with `conda activate llms` if you used Anaconda or `llms\Scripts\activate` if you used the alternative approach in Part 2B
+
+- You should see (llms) in your prompt which is your sign that all is well. And now, type: `jupyter lab` and Jupyter Lab should open up, ready for you to get started. Open the `week1` folder and double click on `day1.ipynb`. 
+
+And you're off to the races!
+
+Note that any time you start jupyter lab in the future, you'll need to follow these Part 5 instructions to start it from within the `llm_engineering` directory with the `llms` environment activated.
+
+For those new to Jupyter Lab / Jupyter Notebook, it's a delightful Data Science environment where you can simply hit shift+return in any cell to run it; start at the top and work your way down! There's a notebook in the week1 folder with a [Guide to Jupyter Lab](week1/Guide%20to%20Jupyter.ipynb), and an [Intermediate Python](week1/Intermediate%20Python.ipynb) tutorial, if that would be helpful. When we move to Google Colab in Week 3, you'll experience the same interface for Python runtimes in the cloud. 
+
+If you have any problems, I've included a notebook in week1 called [troubleshooting.ipynb](week1/troubleshooting.ipynb) to figure it out.
+
+Please do message me or email me at [email protected] if this doesn't work or if I can help with anything. I can't wait to hear how you get on.

SETUP-PC.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d6e2f14564cb5b7fbbbe23125e737047b8a6732627957a08b4400fe18f306da
+size 149380

SETUP-linux.md

@@ -0,0 +1,214 @@
+# LLM Engineering - Master AI and LLMs
+
+## Setup instructions for Linux
+
+Welcome, Linux people!
+
+I should reveal that I had ChatGPT make this document based on the Mac instructions, but then I went through and checked and tweaked some sections. If any of these instructions don't work for your distro, please do reach out and let me know - we'll figure it out, then I'll update the instructions for the future.
+
+___
+
+Setting up a powerful environment to work at the forefront of AI requires some effort, but these instructions should guide you smoothly. If you encounter any issues, don't hesitate to reach out to me. I'm here to ensure you get set up without hassle.
+
+Email: [email protected]  
+LinkedIn: https://www.linkedin.com/in/eddonner/  
+
+For this setup, we'll use Anaconda to create a reliable environment for your AI work. Alternatively, I've provided a lighter option if you prefer to avoid Anaconda. Let's get started!
+
+### Part 1: Clone the Repo
+
+This gets you a local copy of the code on your machine.
+
+1. **Install Git** if not already installed:
+
+- Open your terminal.
+- Run `git --version`. If Git isn't installed, follow the instructions for your distribution:
+  - Debian/Ubuntu: `sudo apt update && sudo apt install git`
+  - Fedora: `sudo dnf install git`
+  - Arch: `sudo pacman -S git`
+
+2. **Navigate to your projects folder:**
+
+If you have a specific folder for projects, navigate to it using the `cd` command. For example:
+`cd ~/Projects`
+
+If you don't have a projects folder, you can create one:
+```
+mkdir ~/Projects
+cd ~/Projects
+```
+
+3. **Clone the repository:**
+
+Run the following command in your terminal:
+`git clone https://github.com/ed-donner/llm_engineering.git`
+
+This creates a new directory `llm_engineering` within your Projects folder and downloads the course code. Use `cd llm_engineering` to enter the directory. This is your "project root directory."
+
+### Part 2: Install Anaconda environment
+
+If this Part 2 gives you any trouble, refer to the alternative Part 2B below.
+
+1. **Install Anaconda:**
+
+- Download the Linux installer from https://www.anaconda.com/download.
+- Open a terminal and navigate to the folder containing the downloaded `.sh` file.
+- Run the installer: `bash Anaconda3*.sh` and follow the prompts. Note: This requires about 5+ GB of disk space.
+
+2. **Set up the environment:**
+
+- Open a terminal and navigate to the "project root directory" using:
+`cd ~/Projects/llm_engineering` (adjust the path as necessary).
+- Run `ls` to confirm the presence of subdirectories for each week of the course.
+- Create the environment: `conda env create -f environment.yml`
+
+This may take several minutes (even up to an hour for new Anaconda users). If it takes longer or errors occur, proceed to Part 2B.
+
+- Activate the environment: `conda activate llms`.
+
+You should see `(llms)` in your prompt, indicating successful activation.
+
+In some distributions this may be required so that the llms environment is visible in jupyter lab:
+
+`conda install ipykernel`  
+`python -m ipykernel install --user --name=llmenv`  
+
+3. **Start Jupyter Lab:**
+
+From the `llm_engineering` folder, run: `jupyter lab`.
+
+Jupyter Lab should open in your browser. Close it after confirming it works, and proceed to Part 3.
+
+### Part 2B - Alternative to Part 2 if Anaconda gives you trouble
+
+1. **Install Python 3.11 (if not already installed):**
+
+- Debian/Ubuntu: `sudo apt update && sudo apt install python3.11`
+- Fedora: `sudo dnf install python3.11`
+- Arch: `sudo pacman -S python`
+
+2. **Navigate to the project root directory:**
+
+Use `cd ~/Projects/llm_engineering` and verify the folder contents with `ls`.
+
+3. **Create a virtual environment:**
+
+Run: `python3.11 -m venv llms`
+
+4. **Activate the virtual environment:**
+
+Use: `source llms/bin/activate`
+
+Your prompt should now display `(llms)`, indicating the environment is active.
+
+5. **Install required packages:**
+
+Run: `python -m pip install --upgrade pip` followed by `pip install -r requirements.txt`.
+
+If issues occur, try the fallback:
+`pip install --retries 5 --timeout 15 --no-cache-dir --force-reinstall -r requirements.txt`
+
+###### Arch users:
+
+Some updates break dependencies. Most notably, numpy, scipy and gensim. To troubleshoot this, you can try many commands:
+
+`sudo pacman -S python-numpy python-pandas python-scipy` This is not recommended, as pacman has no integration with pip (as far as I know)
+
+Another possible solution if having build conflicts, is to update:
+
+`sudo pacman -S gcc gcc-fortran python-setuptools python-wheel`
+
+*Note:* gensim is broken if you have an updated version of scipy. You can either pin scipy to an older version, or 
+erase gensim from the requirements.txt for the moment. (See: https://aur.archlinux.org/packages/python-gensim)
+
+Lastly, so that the kernel is visible after step (6) in jupyter lab :
+`python -m ipykernel install --user --name=llmenv`
+`ipython kernel install --user --name=llmenv`
+
+
+6. **Start Jupyter Lab:**
+
+From the `llm_engineering` folder, run: `jupyter lab`.
+
+
+### Part 3 - OpenAI key (OPTIONAL but recommended)
+
+Particularly during weeks 1 and 2 of the course, you'll be writing code to call the APIs of Frontier models (models at the forefront of AI).
+
+For week 1, you'll only need OpenAI, and you can add the others if you wish later on.
+
+1. Create an OpenAI account if you don't have one by visiting:
+https://platform.openai.com/
+
+2. OpenAI asks for a minimum credit to use the API. For me in the US, it's \$5. The API calls will spend against this \$5. On this course, we'll only use a small portion of this. I do recommend you make the investment as you'll be able to put it to excellent use. But if you'd prefer not to pay for the API, I give you an alternative in the course using Ollama.
+
+You can add your credit balance to OpenAI at Settings > Billing:  
+https://platform.openai.com/settings/organization/billing/overview
+
+I recommend you disable the automatic recharge!
+
+3. Create your API key
+
+The webpage where you set up your OpenAI key is at https://platform.openai.com/api-keys - press the green 'Create new secret key' button and press 'Create secret key'. Keep a record of the API key somewhere private; you won't be able to retrieve it from the OpenAI screens in the future. It should start `sk-proj-`.
+
+In week 2 we will also set up keys for Anthropic and Google, which you can do here when we get there.  
+- Claude API at https://console.anthropic.com/ from Anthropic
+- Gemini API at https://ai.google.dev/gemini-api from Google
+
+Later in the course you'll be using the fabulous HuggingFace platform; an account is available for free at https://huggingface.co - you can create an API token from the Avatar menu >> Settings >> Access Tokens.
+
+And in Week 6/7 you'll be using the terrific Weights & Biases at https://wandb.ai to watch over your training batches. Accounts are also free, and you can set up a token in a similar way.
+
+### PART 4 - .env file
+
+When you have these keys, please create a new file called `.env` in your project root directory. The filename needs to be exactly the four characters ".env" rather than "my-keys.env" or ".env.txt". Here's how to do it:
+
+1. Open Terminal (Applications > Utilities > Terminal)
+
+2. Navigate to the "project root directory" using `cd ~/Documents/Projects/llm_engineering` (replace this path with the actual path to the llm_engineering directory, your locally cloned version of the repo).
+
+3. Create the .env file with
+
+nano .env
+
+4. Then type your API keys into nano, replacing xxxx with your API key (starting `sk-proj-`).
+
+```
+OPENAI_API_KEY=xxxx
+```
+
+If you have other keys, you can add them too, or come back to this in future weeks:  
+```
+GOOGLE_API_KEY=xxxx
+ANTHROPIC_API_KEY=xxxx
+DEEPSEEK_API_KEY=xxxx
+HF_TOKEN=xxxx
+```
+
+5. Save the file:
+
+Control + O  
+Enter (to confirm save the file)  
+Control + X to exit the editor
+
+6. Use this command to list files in your project root directory:
+
+`ls -a`
+
+And confirm that the `.env` file is there.
+
+This file won't appear in Jupyter Lab because jupyter hides files starting with a dot. This file is listed in the `.gitignore` file, so it won't get checked in and your keys stay safe.
+
+### Part 5 - Showtime!!
+
+1. Open a terminal.
+2. Navigate to the "project root directory" using:
+`cd ~/Projects/llm_engineering`.
+3. Activate your environment:
+   - If you used Anaconda: `conda activate llms`
+   - If you used the alternative: `source llms/bin/activate`
+
+You should see `(llms)` in your prompt. Run: `jupyter lab` to get started.
+
+Enjoy your journey into mastering AI and LLMs!
+

SETUP-linux.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c52d2037db403d46c3d8b8ad667d26889de95c0221a5c0ac5031914ff4a21ad
+size 134097

SETUP-mac.md

@@ -0,0 +1,196 @@
+# LLM Engineering - Master AI and LLMs
+
+## Setup instructions for Mac
+
+Welcome, Mac people!
+
+I should confess up-front: setting up a powerful environment to work at the forefront of AI is not as simple as I'd like. For most people these instructions will go great; but in some cases, for whatever reason, you'll hit a problem. Please don't hesitate to reach out - I am here to get you up and running quickly. There's nothing worse than feeling _stuck_. Message me, email me or LinkedIn message me and I will unstick you quickly!
+
+Email: [email protected]  
+LinkedIn: https://www.linkedin.com/in/eddonner/  
+
+I use a platform called Anaconda to set up your environment. It's a powerful tool that builds a complete science environment. Anaconda ensures that you're working with the right version of Python and all your packages are compatible with mine, even if our systems are completely different. It takes more time to set up, and it uses more hard drive space (5+ GB) but it's very reliable once its working.
+
+Having said that: if you have any problems with Anaconda, I've provided an alternative approach. It's faster and simpler and should have you running quickly, with less of a guarantee around compatibility.
+
+### Before we begin
+
+If you're less familiar with using the Terminal, please review this excellent [guide](https://chatgpt.com/canvas/shared/67b0b10c93a081918210723867525d2b) for some details and exercises.
+
+If you're new to developing on your Mac, you may need to install XCode developer tools. Here are [instructions](https://chatgpt.com/share/67b0b8d7-8eec-8012-9a37-6973b9db11f5).
+
+One "gotcha" to keep in mind: if you run anti-virus software, VPN or a Firewall, it might interfere with installations or network access. Please temporarily disable if you have problems.
+
+### Part 1: Clone the Repo
+
+This gets you a local copy of the code on your box.
+
+1. **Install Git** if not already installed (it will be in most cases)
+
+- Open Terminal (Applications > Utilities > Terminal)
+- Type `git --version` If not installed, you'll be prompted to install it  
+- After the installation, you may need to open a new Terminal window to use it (or you might even need to restart)
+
+2. **Navigate to your projects folder:**
+
+If you have a specific folder for projects, navigate to it using the cd command. For example:
+`cd ~/Documents/Projects`
+
+If you don't have a projects folder, you can create one:
+```
+mkdir ~/Documents/Projects
+cd ~/Documents/Projects
+```
+
+3. **Clone the repository:**
+
+Enter this in the terminal in the Projects folder:
+
+`git clone https://github.com/ed-donner/llm_engineering.git`
+
+This creates a new directory `llm_engineering` within your Projects folder and downloads the code for the class. Do `cd llm_engineering` to go into it. This `llm_engineering` directory is known as the "project root directory".
+
+### Part 2: Install Anaconda environment
+
+If this Part 2 gives you any problems, there is an alternative Part 2B below that can be used instead.
+
+1. **Install Anaconda:**
+
+- Download Anaconda from https://docs.anaconda.com/anaconda/install/mac-os/
+- Double-click the downloaded file and follow the installation prompts. Note that it takes up several GB and take a while to install, but it will be a powerful platform for you to use in the future.
+- After installing, you'll need to open a fresh, new Terminal to be able to use it (and you might even need to restart).
+
+2. **Set up the environment:**
+
+- Open a **new** Terminal (Applications > Utilities > Terminal)
+- Navigate to the "project root directory" using `cd ~/Documents/Projects/llm_engineering` (replace this path as needed with the actual path to the llm_engineering directory, your locally cloned version of the repo). Do `ls` and check you can see subdirectories for each week of the course.
+- Create the environment: `conda env create -f environment.yml`
+- Wait for a few minutes for all packages to be installed - in some cases, this can literally take 20-30 minutes if you've not used Anaconda before, and even longer depending on your internet connection. Important stuff is happening! If this runs for more than 1 hour 15 mins, or gives you other problems, please go to Part 2B instead.
+- You have now built an isolated, dedicated AI environment for engineering LLMs, running vector datastores, and so much more! You now need to **activate** it using this command: `conda activate llms`  
+
+You should see `(llms)` in your prompt, which indicates you've activated your new environment.
+
+3. **Start Jupyter Lab:**
+
+- In the Terminal window, from within the `llm_engineering` folder, type: `jupyter lab`
+
+...and Jupyter Lab should open up in a browser. If you've not seen Jupyter Lab before, I'll explain it in a moment! Now close the jupyter lab browser tab, and close the Terminal, and move on to Part 3.
+
+### Part 2B - Alternative to Part 2 if Anaconda gives you trouble
+
+1. **Open a new Terminal** (Applications > Utilities > Terminal)
+
+Run `python --version` to find out which python you're on.  
+Ideally you'd be using a version of Python 3.11, so we're completely in sync.  
+I believe Python 3.12 works also, but (as of Feb 2025) Python 3.13 does **not** yet work as several Data Science dependencies are not yet ready for Python 3.13.  
+If you need to install Python or install another version, you can download it here:  
+https://www.python.org/downloads/
+
+2. Navigate to the "project root directory" using `cd ~/Documents/Projects/llm_engineering` (replace this path with the actual path to the llm_engineering directory, your locally cloned version of the repo). Do `ls` and check you can see subdirectories for each week of the course.  
+
+Then, create a new virtual environment with this command:  
+`python -m venv llms`
+
+3. Activate the virtual environment with  
+`source llms/bin/activate`
+You should see (llms) in your command prompt, which is your sign that things are going well.
+
+4. Run `python -m pip install --upgrade pip` followed by `pip install -r requirements.txt`  
+This may take a few minutes to install.
+In the very unlikely event that this doesn't go well, you should try the bullet-proof (but slower) version:  
+`pip install --retries 5 --timeout 15 --no-cache-dir --force-reinstall -r requirements.txt`
+
+5. **Start Jupyter Lab:**
+
+From within the `llm_engineering` folder, type: `jupyter lab`  
+...and Jupyter Lab should open up, ready for you to get started. Open the `week1` folder and double click on `day1.ipynb`. Success! Now close down jupyter lab and move on to Part 3.
+
+If there are any problems, contact me!
+
+### Part 3 - OpenAI key (OPTIONAL but recommended)
+
+Particularly during weeks 1 and 2 of the course, you'll be writing code to call the APIs of Frontier models (models at the forefront of AI).
+
+For week 1, you'll only need OpenAI, and you can add the others if you wish later on.
+
+1. Create an OpenAI account if you don't have one by visiting:
+https://platform.openai.com/
+
+2. OpenAI asks for a minimum credit to use the API. For me in the US, it's \$5. The API calls will spend against this \$5. On this course, we'll only use a small portion of this. I do recommend you make the investment as you'll be able to put it to excellent use. But if you'd prefer not to pay for the API, I give you an alternative in the course using Ollama.
+
+You can add your credit balance to OpenAI at Settings > Billing:  
+https://platform.openai.com/settings/organization/billing/overview
+
+I recommend you disable the automatic recharge!
+
+3. Create your API key
+
+The webpage where you set up your OpenAI key is at https://platform.openai.com/api-keys - press the green 'Create new secret key' button and press 'Create secret key'. Keep a record of the API key somewhere private; you won't be able to retrieve it from the OpenAI screens in the future. It should start `sk-proj-`.
+
+In week 2 we will also set up keys for Anthropic and Google, which you can do here when we get there.  
+- Claude API at https://console.anthropic.com/ from Anthropic
+- Gemini API at https://ai.google.dev/gemini-api from Google
+
+Later in the course you'll be using the fabulous HuggingFace platform; an account is available for free at https://huggingface.co - you can create an API token from the Avatar menu >> Settings >> Access Tokens.
+
+And in Week 6/7 you'll be using the terrific Weights & Biases at https://wandb.ai to watch over your training batches. Accounts are also free, and you can set up a token in a similar way.
+
+### PART 4 - .env file
+
+When you have these keys, please create a new file called `.env` in your project root directory. The filename needs to be exactly the four characters ".env" rather than "my-keys.env" or ".env.txt". Here's how to do it:
+
+1. Open Terminal (Applications > Utilities > Terminal)
+
+2. Navigate to the "project root directory" using `cd ~/Documents/Projects/llm_engineering` (replace this path with the actual path to the llm_engineering directory, your locally cloned version of the repo).
+
+3. Create the .env file with
+
+nano .env
+
+4. Then type your API keys into nano, replacing xxxx with your API key (starting `sk-proj-`).
+
+```
+OPENAI_API_KEY=xxxx
+```
+
+If you have other keys, you can add them too, or come back to this in future weeks:  
+```
+GOOGLE_API_KEY=xxxx
+ANTHROPIC_API_KEY=xxxx
+DEEPSEEK_API_KEY=xxxx
+HF_TOKEN=xxxx
+```
+
+5. Save the file:
+
+Control + O  
+Enter (to confirm save the file)  
+Control + X to exit the editor
+
+6. Use this command to list files in your project root directory:
+
+`ls -a`
+
+And confirm that the `.env` file is there.
+
+This file won't appear in Jupyter Lab because jupyter hides files starting with a dot. This file is listed in the `.gitignore` file, so it won't get checked in and your keys stay safe.
+
+### Part 5 - Showtime!!
+
+- Open Terminal (Applications > Utilities > Terminal)
+  
+- Navigate to the "project root directory" using `cd ~/Documents/Projects/llm_engineering` (replace this path with the actual path to the llm_engineering directory, your locally cloned version of the repo). Do `ls` and check you can see subdirectories for each week of the course.  
+
+- Activate your environment with `conda activate llms` (or `source llms/bin/activate` if you used the alternative approach in Part 2B)
+
+- You should see (llms) in your prompt which is your sign that all is well. And now, type: `jupyter lab` and Jupyter Lab should open up, ready for you to get started. Open the `week1` folder and double click on `day1.ipynb`.
+
+And you're off to the races!
+
+Note that any time you start jupyter lab in the future, you'll need to follow these Part 5 instructions to start it from within the `llm_engineering` directory with the `llms` environment activated.
+
+For those new to Jupyter Lab / Jupyter Notebook, it's a delightful Data Science environment where you can simply hit shift+return in any cell to run it; start at the top and work your way down! I've included a notebook called 'Guide to Jupyter' that shows you more features. When we move to Google Colab in Week 3, you'll experience the same interface for Python runtimes in the cloud. 
+
+If you have any problems, I've included a notebook in week1 called [troubleshooting.ipynb](week1/troubleshooting.ipynb) to figure it out.
+
+Please do message me or email me at [email protected] if this doesn't work or if I can help with anything. I can't wait to hear how you get on.

SETUP-mac.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:024c05d8f578d1098029760053fc5dcd29d92ee8b1f4b4950dd0f9cf41e6156c
+size 147551

community-contributions/playwright-bojan/Playwright_Solution_JupyterAsync.ipynb

@@ -0,0 +1,173 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "aa629e55-8f41-41ab-b319-b55dd1cfc76b",
+   "metadata": {},
+   "source": [
+    "# Playwright Scraper Showcase (Async in Jupyter)\n",
+    "\n",
+    "This notebook demonstrates how to run async Playwright-based scraping code inside JupyterLab using `nest_asyncio`.\n",
+    "\n",
+    "**Note:** Requires `openai_scraper_playwright.py` to be in the same directory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "97469777",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import nest_asyncio\n",
+    "import asyncio\n",
+    "nest_asyncio.apply()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "6254fa89",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from openai_scraper_playwright import EnhancedOpenAIScraper, analyze_content"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "33d2737b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "### 1. Overall Summary of the Website:\n",
+      "The website appears to be a hub for various applications of AI technology, particularly focusing on the capabilities of ChatGPT and other AI models developed by OpenAI. It offers a range of services from answering queries, assisting in planning trips, explaining technical topics, helping with language translation, and providing educational content. The site also features updates on new AI models, research publications, and business solutions integrating AI.\n",
+      "\n",
+      "### 2. Key Individuals or Entities:\n",
+      "- **OpenAI**: Mentioned as the organization behind the development of AI models and technologies such as ChatGPT, GPT-4.1, and image generation models. OpenAI seems to be focused on advancing and applying AI in various fields.\n",
+      "- **Lyndon Barrois & Sora**: Featured in a story, possibly highlighting individual experiences or contributions within the OpenAI ecosystem.\n",
+      "\n",
+      "### 3. Recent Announcements or Updates:\n",
+      "- **Introducing our latest image generation model in the API** (Product, Apr 23, 2025)\n",
+      "- **Thinking with images** (Release, Apr 16, 2025)\n",
+      "- **OpenAI announces nonprofit commission advisors** (Company, Apr 15, 2025)\n",
+      "- **Our updated Preparedness Framework** (Publication, Apr 15, 2025)\n",
+      "- **BrowseComp: a benchmark for browsing agents** (Publication, Apr 10, 2025)\n",
+      "- **OpenAI Pioneers Program** (Company, Apr 9, 2025)\n",
+      "\n",
+      "### 4. Main Topics or Themes:\n",
+      "- **AI Model Development and Application**: Discusses various AI models like ChatGPT, GPT-4.1, and image generation models.\n",
+      "- **Educational and Practical AI Uses**: Offers help in educational topics, practical tasks, and creative endeavors using AI.\n",
+      "- **Business Integration**: Focuses on integrating AI into business processes, automating tasks in finance, legal, and other sectors.\n",
+      "- **Research and Publications**: Shares updates on the latest research and publications related to AI technology.\n",
+      "\n",
+      "### 5. Any Noteworthy Features or Projects:\n",
+      "- **GPT-4.1 and Image Generation Models**: Introduction of new and advanced AI models for text and image processing.\n",
+      "- **OpenAI Pioneers Program**: A significant initiative likely aimed at fostering innovation and practical applications of AI technology.\n",
+      "- **BrowseComp and PaperBench**: Research projects or benchmarks designed to evaluate and improve AI capabilities in specific domains.\n"
+     ]
+    }
+   ],
+   "source": [
+    "result = asyncio.run(analyze_content())\n",
+    "print(result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d7450ccf",
+   "metadata": {},
+   "source": [
+    "✅ If you see structured analysis above, the async code ran successfully in Jupyter!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9a46716c-6f77-4b2b-b423-cc9fe05014da",
+   "metadata": {},
+   "source": [
+    "# 🧪 Playwright Scraper Output (Formatted)\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## 🧭 1. **Overall Summary of the Website**\n",
+    "\n",
+    "*The website appears to be focused on showcasing various applications and updates related to OpenAI's technology, specifically ChatGPT and other AI tools. It provides information on product releases, company updates, and educational content on how to use AI technologies in different scenarios such as planning trips, learning games, coding, and more.*\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## 🧑‍💼 2. **Key Individuals or Entities**\n",
+    "\n",
+    "- **OpenAI** — Company behind the technologies and updates discussed on the website  \n",
+    "- **Lyndon Barrois & Sora** — Featured in a story, possibly highlighting user experiences or contributions\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## 📰 3. **Recent Announcements or Updates**\n",
+    "\n",
+    "- 📢 **Introducing GPT-4.1 in the API** — *(no date provided)*\n",
+    "- 🖼️ **Introducing 4o Image Generation** — *(no date provided)*\n",
+    "- 🐟 **Catching halibut with ChatGPT** — *(no date provided)*\n",
+    "- 🧠 **Thinking with images** — *Apr 16, 2025*\n",
+    "- 🧑‍⚖️ **Nonprofit commission advisors announced** — *Apr 15, 2025*\n",
+    "- ⚙️ **Updated Preparedness Framework** — *Apr 15, 2025*\n",
+    "- 🌐 **BrowseComp benchmark for browsing agents** — *Apr 10, 2025*\n",
+    "- 🚀 **OpenAI Pioneers Program launched** — *Apr 9, 2025*\n",
+    "- 📊 **PaperBench research benchmark published** — *Apr 2, 2025*\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## 📚 4. **Main Topics or Themes**\n",
+    "\n",
+    "- 🤖 **AI Technology Applications** — Using AI for tasks like planning, learning, and troubleshooting  \n",
+    "- 🧩 **Product and Feature Releases** — Updates on new capabilities  \n",
+    "- 📘 **Educational Content** — Guides for using AI effectively  \n",
+    "- 🧪 **Research and Development** — Publications and technical benchmarks\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## ⭐ 5. **Noteworthy Features or Projects**\n",
+    "\n",
+    "- ✅ **GPT-4.1** — A new API-accessible version of the language model  \n",
+    "- 🖼️ **4o Image Generation** — Feature focused on AI-generated images  \n",
+    "- 🚀 **OpenAI Pioneers Program** — Initiative likely fostering innovation in AI  \n",
+    "- 📊 **BrowseComp & PaperBench** — Benchmarks for evaluating AI agents\n",
+    "\n",
+    "---\n",
+    "\n",
+    "✅ *If you're reading this inside Jupyter and seeing clean structure — your async notebook setup is working beautifully.*\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95c38374-5daa-487c-8bd9-919bb4037ea3",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/playwright-bojan/Playwright_Solution_Showcase_Formatted.ipynb

@@ -0,0 +1,69 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3df9df94",
+   "metadata": {},
+   "source": [
+    "# 🧪 Playwright Scraper Output (Formatted)\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## 🧭 1. **Overall Summary of the Website**\n",
+    "\n",
+    "*The website appears to be focused on showcasing various applications and updates related to OpenAI's technology, specifically ChatGPT and other AI tools. It provides information on product releases, company updates, and educational content on how to use AI technologies in different scenarios such as planning trips, learning games, coding, and more.*\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## 🧑‍💼 2. **Key Individuals or Entities**\n",
+    "\n",
+    "- **OpenAI** — Company behind the technologies and updates discussed on the website  \n",
+    "- **Lyndon Barrois & Sora** — Featured in a story, possibly highlighting user experiences or contributions\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## 📰 3. **Recent Announcements or Updates**\n",
+    "\n",
+    "- 📢 **Introducing GPT-4.1 in the API** — *(no date provided)*\n",
+    "- 🖼️ **Introducing 4o Image Generation** — *(no date provided)*\n",
+    "- 🐟 **Catching halibut with ChatGPT** — *(no date provided)*\n",
+    "- 🧠 **Thinking with images** — *Apr 16, 2025*\n",
+    "- 🧑‍⚖️ **Nonprofit commission advisors announced** — *Apr 15, 2025*\n",
+    "- ⚙️ **Updated Preparedness Framework** — *Apr 15, 2025*\n",
+    "- 🌐 **BrowseComp benchmark for browsing agents** — *Apr 10, 2025*\n",
+    "- 🚀 **OpenAI Pioneers Program launched** — *Apr 9, 2025*\n",
+    "- 📊 **PaperBench research benchmark published** — *Apr 2, 2025*\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## 📚 4. **Main Topics or Themes**\n",
+    "\n",
+    "- 🤖 **AI Technology Applications** — Using AI for tasks like planning, learning, and troubleshooting  \n",
+    "- 🧩 **Product and Feature Releases** — Updates on new capabilities  \n",
+    "- 📘 **Educational Content** — Guides for using AI effectively  \n",
+    "- 🧪 **Research and Development** — Publications and technical benchmarks\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## ⭐ 5. **Noteworthy Features or Projects**\n",
+    "\n",
+    "- ✅ **GPT-4.1** — A new API-accessible version of the language model  \n",
+    "- 🖼️ **4o Image Generation** — Feature focused on AI-generated images  \n",
+    "- 🚀 **OpenAI Pioneers Program** — Initiative likely fostering innovation in AI  \n",
+    "- 📊 **BrowseComp & PaperBench** — Benchmarks for evaluating AI agents\n",
+    "\n",
+    "---\n",
+    "\n",
+    "✅ *If you're reading this inside Jupyter and seeing clean structure — your async notebook setup is working beautifully.*\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

community-contributions/playwright-bojan/README.md

@@ -0,0 +1,67 @@
+# 🧠 Community Contribution: Async Playwright-based OpenAI Scraper
+
+This contribution presents a fully asynchronous, headless-browser-based scraper for [https://openai.com](https://openai.com) using **Playwright** — an alternative to Selenium.
+
+Developed by: [lakovicb](https://github.com/lakovicb)  
+IDE used: WingIDE Pro (Jupyter compatibility via `nest_asyncio`)
+
+---
+
+## 📦 Features
+
+- 🧭 Simulates human-like interactions (mouse movement, scrolling)
+- 🧠 GPT-based analysis using OpenAI's API
+- 🧪 Works inside **JupyterLab** using `nest_asyncio`
+- 📊 Prometheus metrics for scraping observability
+- ⚡ Smart content caching via `diskcache`
+
+---
+
+## 🚀 How to Run
+
+### 1. Install dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+> Ensure [Playwright is installed & browsers are downloaded](https://playwright.dev/python/docs/intro)
+
+```bash
+playwright install
+```
+
+### 2. Set environment variables in `.env`
+
+```env
+OPENAI_API_KEY=your_openai_key
+BROWSER_PATH=/usr/bin/chromium-browser
+```
+
+You can also define optional proxy/login params if needed.
+
+---
+
+## 📘 Notebooks Included
+
+| Notebook | Description |
+|----------|-------------|
+| `Playwright_Solution_JupyterAsync.ipynb` | Executes async scraper directly inside Jupyter |
+| `Playwright_Solution_Showcase_Formatted.ipynb` | Nicely formatted output for human reading |
+
+---
+
+## 🔁 Output Example
+
+- GPT-generated summary
+- Timeline of updates
+- Entities and projects mentioned
+- Structured topics & themes
+
+✅ *Can be extended with PDF export, LangChain pipeline, or vector store ingestion.*
+
+---
+
+## 🙏 Thanks
+
+Huge thanks to Ed Donner for the amazing course and challenge inspiration!

community-contributions/playwright-bojan/openai_scraper_playwright.py

@@ -0,0 +1,141 @@
+# openai_scraper_playwright.py
+
+import asyncio
+from playwright.async_api import async_playwright
+from openai import OpenAI
+import logging
+import random
+import time
+import os
+from prometheus_client import start_http_server, Counter, Histogram
+from diskcache import Cache
+from dotenv import load_dotenv
+
+load_dotenv()
+
+SCRAPE_ATTEMPTS = Counter('scrape_attempts', 'Total scraping attempts')
+SCRAPE_DURATION = Histogram('scrape_duration', 'Scraping duration distribution')
+cache = Cache('./scraper_cache')
+
+class ScrapingError(Exception): pass
+class ContentAnalysisError(Exception): pass
+
+class EnhancedOpenAIScraper:
+    API_KEY = os.getenv("OPENAI_API_KEY")
+    BROWSER_EXECUTABLE = os.getenv("BROWSER_PATH", "/usr/bin/chromium-browser")
+    MAX_CONTENT_LENGTH = int(os.getenv("MAX_CONTENT_LENGTH", 30000))
+
+    def __init__(self, headless=True):
+        self.user_agents = [
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64)...",
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)..."
+        ]
+        self.timeout = 45000
+        self.retry_count = int(os.getenv("RETRY_COUNT", 2))
+        self.headless = headless
+        self.proxy_servers = [x.strip() for x in os.getenv("PROXY_SERVERS", "").split(',') if x.strip()]
+
+    async def human_interaction(self, page):
+        for _ in range(random.randint(2, 5)):
+            x, y = random.randint(0, 1366), random.randint(0, 768)
+            await page.mouse.move(x, y, steps=random.randint(5, 20))
+            await page.wait_for_timeout(random.randint(50, 200))
+
+        if random.random() < 0.3:
+            await page.keyboard.press('Tab')
+            await page.keyboard.type(' ', delay=random.randint(50, 200))
+
+        await page.mouse.wheel(0, random.choice([300, 600, 900]))
+        await page.wait_for_timeout(random.randint(500, 2000))
+
+    async def load_page(self, page, url):
+        try:
+            await page.goto(url, wait_until="domcontentloaded", timeout=self.timeout)
+            selectors = ['main article', '#main-content', 'section:first-of-type', 'div[class*="content"]', 'body']
+            for selector in selectors:
+                if await page.query_selector(selector):
+                    return True
+            await page.wait_for_timeout(5000)
+            return True
+        except Exception as e:
+            logging.error(f"Error loading page {url}: {e}")
+            return False
+
+    @SCRAPE_DURATION.time()
+    async def scrape_with_retry(self, url):
+        SCRAPE_ATTEMPTS.inc()
+        last_error = None
+        try:
+            async with async_playwright() as p:
+                args = {
+                    "headless": self.headless,
+                    "args": ["--disable-blink-features=AutomationControlled", "--no-sandbox"],
+                    "executable_path": self.BROWSER_EXECUTABLE
+                }
+                browser = await p.chromium.launch(**args)
+                context = await browser.new_context(user_agent=random.choice(self.user_agents))
+                page = await context.new_page()
+                await page.add_init_script("""
+                    Object.defineProperty(navigator, 'webdriver', { get: () => false });
+                """)
+
+                for attempt in range(self.retry_count):
+                    try:
+                        if not await self.load_page(page, url):
+                            raise ScrapingError("Failed to load page")
+                        await self.human_interaction(page)
+                        content = await page.evaluate("""() => document.body.innerText""")
+                        if not content.strip():
+                            raise ContentAnalysisError("No content extracted")
+                        await browser.close()
+                        return content[:self.MAX_CONTENT_LENGTH]
+                    except Exception as e:
+                        last_error = e
+                        if attempt < self.retry_count - 1:
+                            await asyncio.sleep(5)
+                        else:
+                            await browser.close()
+                            raise
+        except Exception as e:
+            raise last_error or e
+
+    async def get_cached_content(self, url):
+        key = 'cache_' + url.replace('https://', '').replace('/', '_')
+        content = cache.get(key)
+        if content is None:
+            content = await self.scrape_with_retry(url)
+            cache.set(key, content, expire=int(os.getenv("CACHE_EXPIRY", 3600)))
+        return content
+
+async def analyze_content(url="https://openai.com", headless=True):
+    scraper = EnhancedOpenAIScraper(headless=headless)
+    content = await scraper.get_cached_content(url)
+    client = OpenAI(api_key=EnhancedOpenAIScraper.API_KEY)
+    if not client.api_key:
+        raise ContentAnalysisError("OpenAI API key not configured")
+
+    prompt = f"""
+Analyze this page:
+
+{content}
+    """
+    model = os.getenv("OPENAI_MODEL", "gpt-4-turbo")
+    temperature = float(os.getenv("MODEL_TEMPERATURE", 0.3))
+    max_tokens = int(os.getenv("MAX_TOKENS", 1500))
+    top_p = float(os.getenv("MODEL_TOP_P", 0.9))
+
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": "You are a content analyst."},
+            {"role": "user", "content": prompt}
+        ],
+        temperature=temperature,
+        max_tokens=max_tokens,
+        top_p=top_p
+    )
+
+    if not response.choices:
+        raise ContentAnalysisError("Empty response from GPT")
+
+    return response.choices[0].message.content

community-contributions/playwright-bojan/requirements.txt

@@ -0,0 +1,6 @@
+playwright>=1.43.0
+openai>=1.14.2
+prometheus-client>=0.19.0
+diskcache>=5.6.1
+python-dotenv>=1.0.1
+nest_asyncio>=1.6.0

diagnostics.ipynb

@@ -0,0 +1,54 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "73287ed4-81e3-496a-9e47-f0e8c3770ce9",
+   "metadata": {},
+   "source": [
+    "# Gathering Essential Diagnostic information\n",
+    "\n",
+    "## Please run this next cell to gather some important data\n",
+    "\n",
+    "Please run the next cell; it should take a minute or so to run (mostly the network test).\n",
+    "Rhen email me the output of the last cell to [email protected].  \n",
+    "Alternatively: this will create a file called report.txt - just attach the file to your email."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ed8056e8-efa2-4b6f-a4bb-e7ceb733c517",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run my diagnostics report to collect key information for debugging\n",
+    "# Please email me the results. Either copy & paste the output, or attach the file report.txt\n",
+    "\n",
+    "!pip install -q requests speedtest-cli psutil setuptools\n",
+    "from diagnostics import Diagnostics\n",
+    "Diagnostics().run()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

diagnostics.py

@@ -0,0 +1,419 @@
+import os
+import sys
+import platform
+import subprocess
+import shutil
+import time
+import ssl
+import tempfile
+from pathlib import Path
+from datetime import datetime
+
+class Diagnostics:
+
+    FILENAME = 'report.txt'
+    
+    def __init__(self):
+        self.errors = []
+        self.warnings = []
+        if os.path.exists(self.FILENAME):
+            os.remove(self.FILENAME)
+
+    def log(self, message):
+        print(message)
+        with open(self.FILENAME, 'a', encoding='utf-8') as f:
+            f.write(message + "\n")
+
+    def start(self):
+        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self.log(f"Starting diagnostics at {now}\n")
+
+    def end(self):
+        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self.log(f"\n\nCompleted diagnostics at {now}\n")
+        print("\nPlease send these diagnostics to me at [email protected]")
+        print(f"Either copy & paste the above output into an email, or attach the file {self.FILENAME} that has been created in this directory.")
+    
+
+    def _log_error(self, message):
+        self.log(f"ERROR: {message}")
+        self.errors.append(message)
+
+    def _log_warning(self, message):
+        self.log(f"WARNING: {message}")
+        self.warnings.append(message)
+
+    def run(self):
+        self.start()
+        self._step1_system_info()
+        self._step2_check_files()
+        self._step3_git_repo()
+        self._step4_check_env_file()
+        self._step5_anaconda_check()
+        self._step6_virtualenv_check()
+        self._step7_network_connectivity()
+        self._step8_environment_variables()
+        self._step9_additional_diagnostics()
+
+        if self.warnings:
+            self.log("\n===== Warnings Found =====")
+            self.log("The following warnings were detected. They might not prevent the program from running but could cause unexpected behavior:")
+            for warning in self.warnings:
+                self.log(f"- {warning}")
+
+        if self.errors:
+            self.log("\n===== Errors Found =====")
+            self.log("The following critical issues were detected. Please address them before proceeding:")
+            for error in self.errors:
+                self.log(f"- {error}")
+
+        if not self.errors and not self.warnings:
+            self.log("\n✅ All diagnostics passed successfully!")
+
+        self.end()
+
+    def _step1_system_info(self):
+        self.log("===== System Information =====")
+        try:
+            system = platform.system()
+            self.log(f"Operating System: {system}")
+
+            if system == "Windows":
+                release, version, csd, ptype = platform.win32_ver()
+                self.log(f"Windows Release: {release}")
+                self.log(f"Windows Version: {version}")
+            elif system == "Darwin":
+                release, version, machine = platform.mac_ver()
+                self.log(f"MacOS Version: {release}")
+            else:
+                self.log(f"Platform: {platform.platform()}")
+
+            self.log(f"Architecture: {platform.architecture()}")
+            self.log(f"Machine: {platform.machine()}")
+            self.log(f"Processor: {platform.processor()}")
+
+            try:
+                import psutil
+                ram = psutil.virtual_memory()
+                total_ram_gb = ram.total / (1024 ** 3)
+                available_ram_gb = ram.available / (1024 ** 3)
+                self.log(f"Total RAM: {total_ram_gb:.2f} GB")
+                self.log(f"Available RAM: {available_ram_gb:.2f} GB")
+
+                if available_ram_gb < 2:
+                    self._log_warning(f"Low available RAM: {available_ram_gb:.2f} GB")
+            except ImportError:
+                self._log_warning("psutil module not found. Cannot determine RAM information.")
+
+            total, used, free = shutil.disk_usage(os.path.expanduser("~"))
+            free_gb = free / (1024 ** 3)
+            self.log(f"Free Disk Space: {free_gb:.2f} GB")
+
+            if free_gb < 5:
+                self._log_warning(f"Low disk space: {free_gb:.2f} GB free")
+
+        except Exception as e:
+            self._log_error(f"System information check failed: {e}")
+
+    def _step2_check_files(self):
+        self.log("\n===== File System Information =====")
+        try:
+            current_dir = os.getcwd()
+            self.log(f"Current Directory: {current_dir}")
+
+            # Check write permissions
+            test_file = Path(current_dir) / ".test_write_permission"
+            try:
+                test_file.touch(exist_ok=True)
+                test_file.unlink()
+                self.log("Write permission: OK")
+            except Exception as e:
+                self._log_error(f"No write permission in current directory: {e}")
+
+            self.log("\nFiles in Current Directory:")
+            try:
+                for item in sorted(os.listdir(current_dir)):
+                    self.log(f" - {item}")
+            except Exception as e:
+                self._log_error(f"Cannot list directory contents: {e}")
+
+        except Exception as e:
+            self._log_error(f"File system check failed: {e}")
+
+    def _step3_git_repo(self):
+        self.log("\n===== Git Repository Information =====")
+        try:
+            result = subprocess.run(['git', 'rev-parse', '--show-toplevel'],
+                                    stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            if result.returncode == 0:
+                git_root = result.stdout.strip()
+                self.log(f"Git Repository Root: {git_root}")
+
+                result = subprocess.run(['git', 'rev-parse', 'HEAD'],
+                                        stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+                if result.returncode == 0:
+                    self.log(f"Current Commit: {result.stdout.strip()}")
+                else:
+                    self._log_warning(f"Could not get current commit: {result.stderr.strip()}")
+
+                result = subprocess.run(['git', 'remote', 'get-url', 'origin'],
+                                        stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+                if result.returncode == 0:
+                    self.log(f"Remote Origin: {result.stdout.strip()}")
+                else:
+                    self._log_warning("No remote 'origin' configured")
+            else:
+                self._log_warning("Not a git repository")
+        except FileNotFoundError:
+            self._log_warning("Git is not installed or not in PATH")
+        except Exception as e:
+            self._log_error(f"Git check failed: {e}")
+
+    def _step4_check_env_file(self):
+        self.log("\n===== Environment File Check =====")
+        try:
+            result = subprocess.run(['git', 'rev-parse', '--show-toplevel'],
+                                    stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            if result.returncode == 0:
+                git_root = result.stdout.strip()
+                env_path = os.path.join(git_root, '.env')
+
+                if os.path.isfile(env_path):
+                    self.log(f".env file exists at: {env_path}")
+                    try:
+                        with open(env_path, 'r') as f:
+                            has_api_key = any(line.strip().startswith('OPENAI_API_KEY=') for line in f)
+                        if has_api_key:
+                            self.log("OPENAI_API_KEY found in .env file")
+                        else:
+                            self._log_warning("OPENAI_API_KEY not found in .env file")
+                    except Exception as e:
+                        self._log_error(f"Cannot read .env file: {e}")
+                else:
+                    self._log_warning(".env file not found in project root")
+
+                # Check for additional .env files
+                for root, _, files in os.walk(git_root):
+                    if '.env' in files and os.path.join(root, '.env') != env_path:
+                        self._log_warning(f"Additional .env file found at: {os.path.join(root, '.env')}")
+            else:
+                self._log_warning("Git root directory not found. Cannot perform .env file check.")
+        except FileNotFoundError:
+            self._log_warning("Git is not installed or not in PATH")
+        except Exception as e:
+            self._log_error(f"Environment file check failed: {e}")
+
+    def _step5_anaconda_check(self):
+        self.log("\n===== Anaconda Environment Check =====")
+        try:
+            conda_prefix = os.environ.get('CONDA_PREFIX')
+            if conda_prefix:
+                self.log("Anaconda environment is active:")
+                self.log(f"Environment Path: {conda_prefix}")
+                self.log(f"Environment Name: {os.path.basename(conda_prefix)}")
+
+                conda_exe = os.environ.get('CONDA_EXE', 'conda')
+                result = subprocess.run([conda_exe, '--version'],
+                                        stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+                if result.returncode == 0:
+                    self.log(f"Conda Version: {result.stdout.strip()}")
+                else:
+                    self._log_warning("Could not determine Conda version")
+
+                self._check_python_packages()
+            else:
+                self.log("No active Anaconda environment detected")
+        except Exception as e:
+            self._log_error(f"Anaconda environment check failed: {e}")
+
+    def _step6_virtualenv_check(self):
+        self.log("\n===== Virtualenv Check =====")
+        try:
+            virtual_env = os.environ.get('VIRTUAL_ENV')
+            if virtual_env:
+                self.log("Virtualenv is active:")
+                self.log(f"Environment Path: {virtual_env}")
+                self.log(f"Environment Name: {os.path.basename(virtual_env)}")
+
+                self._check_python_packages()
+            else:
+                self.log("No active virtualenv detected")
+
+            if not virtual_env and not os.environ.get('CONDA_PREFIX'):
+                self._log_warning("Neither virtualenv nor Anaconda environment is active")
+        except Exception as e:
+            self._log_error(f"Virtualenv check failed: {e}")
+
+    def _check_python_packages(self):
+        self.log("\nPython Environment:")
+        self.log(f"Python Version: {sys.version}")
+        self.log(f"Python Executable: {sys.executable}")
+
+        required_packages = ['openai', 'python-dotenv', 'requests', 'gradio', 'transformers']
+
+        try:
+            import pkg_resources
+            installed = {pkg.key: pkg.version for pkg in pkg_resources.working_set}
+
+            self.log("\nRequired Package Versions:")
+            for package in required_packages:
+                if package in installed:
+                    self.log(f"{package}: {installed[package]}")
+                else:
+                    self._log_error(f"Required package '{package}' is not installed")
+
+            # Check for potentially conflicting packages
+            problem_pairs = [
+                ('openai', 'openai-python'),
+                ('python-dotenv', 'dotenv')
+            ]
+
+            for pkg1, pkg2 in problem_pairs:
+                if pkg1 in installed and pkg2 in installed:
+                    self._log_warning(f"Potentially conflicting packages: {pkg1} and {pkg2}")
+        except ImportError:
+            self._log_error("Could not import 'pkg_resources' to check installed packages")
+        except Exception as e:
+            self._log_error(f"Package check failed: {e}")
+
+    def _step7_network_connectivity(self):
+        self.log("\n===== Network Connectivity Check =====")
+        try:
+            self.log(f"SSL Version: {ssl.OPENSSL_VERSION}")
+    
+            import requests
+            import speedtest  # Importing the speedtest-cli library
+    
+            # Basic connectivity check
+            urls = [
+                'https://www.google.com',
+                'https://www.cloudflare.com'
+            ]
+    
+            connected = False
+            for url in urls:
+                try:
+                    start_time = time.time()
+                    response = requests.get(url, timeout=10)
+                    elapsed_time = time.time() - start_time
+                    response.raise_for_status()
+                    self.log(f"✓ Connected to {url}")
+                    self.log(f"  Response time: {elapsed_time:.2f}s")
+    
+                    if elapsed_time > 2:
+                        self._log_warning(f"Slow response from {url}: {elapsed_time:.2f}s")
+                    connected = True
+                    break
+                except requests.exceptions.RequestException as e:
+                    self._log_warning(f"Failed to connect to {url}: {e}")
+                else:
+                    self.log("Basic connectivity OK")
+    
+            if not connected:
+                self._log_error("Failed to connect to any test URLs")
+                return
+    
+            # Bandwidth test using speedtest-cli
+            self.log("\nPerforming bandwidth test using speedtest-cli...")
+            try:
+                st = speedtest.Speedtest()
+                st.get_best_server()
+                download_speed = st.download()  # Bits per second
+                upload_speed = st.upload()      # Bits per second
+    
+                download_mbps = download_speed / 1e6  # Convert to Mbps
+                upload_mbps = upload_speed / 1e6
+    
+                self.log(f"Download speed: {download_mbps:.2f} Mbps")
+                self.log(f"Upload speed: {upload_mbps:.2f} Mbps")
+    
+                if download_mbps < 1:
+                    self._log_warning("Download speed is low")
+                if upload_mbps < 0.5:
+                    self._log_warning("Upload speed is low")
+            except speedtest.ConfigRetrievalError:
+                self._log_error("Failed to retrieve speedtest configuration")
+            except Exception as e:
+                self._log_warning(f"Bandwidth test failed: {e}")
+    
+        except ImportError:
+            self._log_error("Required packages are not installed. Please install them using 'pip install requests speedtest-cli'")
+        except Exception as e:
+            self._log_error(f"Network connectivity check failed: {e}")
+
+
+    def _step8_environment_variables(self):
+        self.log("\n===== Environment Variables Check =====")
+        try:
+            # Check Python paths
+            pythonpath = os.environ.get('PYTHONPATH')
+            if pythonpath:
+                self.log("\nPYTHONPATH:")
+                for path in pythonpath.split(os.pathsep):
+                    self.log(f" - {path}")
+            else:
+                self.log("\nPYTHONPATH is not set.")
+
+            self.log("\nPython sys.path:")
+            for path in sys.path:
+                self.log(f" - {path}")
+
+            # Check OPENAI_API_KEY
+            from dotenv import load_dotenv
+            load_dotenv()
+            api_key = os.environ.get('OPENAI_API_KEY')
+            if api_key:
+                self.log("OPENAI_API_KEY is set after calling load_dotenv()")
+                if not api_key.startswith('sk-proj-') or len(api_key)<12:
+                    self._log_warning("OPENAI_API_KEY format looks incorrect after calling load_dotenv()")
+            else:
+                self._log_warning("OPENAI_API_KEY environment variable is not set after calling load_dotenv()")
+        except Exception as e:
+            self._log_error(f"Environment variables check failed: {e}")
+
+    def _step9_additional_diagnostics(self):
+        self.log("\n===== Additional Diagnostics =====")
+        try:
+            # Get the site-packages directory paths
+            import site
+            site_packages_paths = site.getsitepackages()
+            if hasattr(site, 'getusersitepackages'):
+                site_packages_paths.append(site.getusersitepackages())
+    
+            # Function to check if a path is within site-packages
+            def is_in_site_packages(path):
+                return any(os.path.commonpath([path, sp]) == sp for sp in site_packages_paths)
+    
+            # Check for potential name conflicts in the current directory and sys.path
+            conflict_names = ['openai.py', 'dotenv.py']
+    
+            # Check current directory
+            current_dir = os.getcwd()
+            for name in conflict_names:
+                conflict_path = os.path.join(current_dir, name)
+                if os.path.isfile(conflict_path):
+                    self._log_warning(f"Found '{name}' in the current directory, which may cause import conflicts: {conflict_path}")
+    
+            # Check sys.path directories
+            for path in sys.path:
+                if not path or is_in_site_packages(path):
+                    continue  # Skip site-packages and empty paths
+                for name in conflict_names:
+                    conflict_file = os.path.join(path, name)
+                    if os.path.isfile(conflict_file):
+                        self._log_warning(f"Potential naming conflict: {conflict_file}")
+    
+            # Check temp directory
+            try:
+                with tempfile.NamedTemporaryFile() as tmp:
+                    self.log(f"Temp directory is writable: {os.path.dirname(tmp.name)}")
+            except Exception as e:
+                self._log_error(f"Cannot write to temp directory: {e}")
+    
+        except Exception as e:
+            self._log_error(f"Additional diagnostics failed: {e}")
+
+
+if __name__ == "__main__":
+    diagnostics = Diagnostics()
+    diagnostics.run()

environment.yml

@@ -0,0 +1,50 @@
+name: llms
+channels:
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.11
+  - pip
+  - python-dotenv
+  - requests
+  - numpy
+  - pandas
+  - scipy
+  - pytorch
+  - jupyterlab
+  - ipywidgets
+  - matplotlib
+  - scikit-learn
+  - chromadb
+  - jupyter-dash
+  - sentencepiece
+  - pyarrow
+  - faiss-cpu
+  - pip:
+    - beautifulsoup4
+    - plotly
+    - bitsandbytes
+    - transformers
+    - sentence-transformers
+    - datasets
+    - accelerate
+    - openai
+    - anthropic
+    - google-generativeai
+    - gradio
+    - gensim
+    - modal
+    - ollama
+    - psutil
+    - setuptools
+    - speedtest-cli
+    - langchain
+    - langchain-core
+    - langchain-text-splitters
+    - langchain-openai
+    - langchain-chroma
+    - langchain-community
+    - faiss-cpu
+    - feedparser
+    - twilio
+    - pydub

extras/community/prototype_signal.ipynb

@@ -0,0 +1,413 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7e2c4bbb-5e8b-4d84-9997-ecb2c349cf54",
+   "metadata": {},
+   "source": [
+    "## First step - generate training data from examples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "id": "16cf3aa2-f407-4b95-8b9e-c3c586f67835",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import requests\n",
+    "import pandas as pd\n",
+    "from datetime import datetime, timedelta,timezone\n",
+    "from datasets import load_dataset, Dataset\n",
+    "from dotenv import load_dotenv\n",
+    "import os\n",
+    "from openai import OpenAI\n",
+    "import json\n",
+    "import tiktoken\n",
+    "from IPython.display import display, Markdown\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "id": "375302b6-b6a7-46ea-a74c-c2400dbd8bbe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load environment variables in a file called .env\n",
+    "load_dotenv()\n",
+    "\n",
+    "# Replace with your CoinAPI key\n",
+    "API_KEY = os.getenv('YOUR_COINAPI_KEY')\n",
+    "\n",
+    "# Define the base URL for CoinAPI\n",
+    "BASE_URL = 'https://rest.coinapi.io/v1/ohlcv/'\n",
+    "OLLAMA_URL = \"http://localhost:11434/v1\"\n",
+    "\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "# URL to fetch the OHLCV data\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 98,
+   "id": "d0cc964d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai = OpenAI()\n",
+    "\n",
+    "ollama = OpenAI(\n",
+    "    base_url=OLLAMA_URL,\n",
+    "    api_key='OLAMMA'\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "id": "8a0c9fff-9eff-42fd-971b-403c99d9b726",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the symbol and timeframe\n",
+    "base_data = {\n",
+    "    'name': 'Cardano',\n",
+    "    'symbol': f'BINANCE_SPOT_ADA_USDT',\n",
+    "    'timeframe': '1DAY',\n",
+    "    'time_range': 365 * 2\n",
+    "}\n",
+    "\n",
+    "\n",
+    "# Calculate the start date for one year ago\n",
+    "end_date = datetime.now(tz=timezone.utc)\n",
+    "\n",
+    "start_date = end_date - timedelta(days=base_data['time_range'])\n",
+    "\n",
+    "# Format the dates in the required format (ISO 8601)\n",
+    "start_date_str = start_date.strftime('%Y-%m-%dT%H:%M:%S')\n",
+    "end_date_str = end_date.strftime('%Y-%m-%dT%H:%M:%S')\n",
+    "\n",
+    "# Headers for authentication\n",
+    "headers = {\n",
+    "    'X-CoinAPI-Key': API_KEY\n",
+    "}\n",
+    "\n",
+    "# URL to fetch the OHLCV base_data\n",
+    "url = f'{BASE_URL}{base_data['symbol']}/history'\n",
+    "\n",
+    "# Request parameters\n",
+    "params = {\n",
+    "    'period_id': base_data['timeframe'],\n",
+    "    'time_start': start_date_str,\n",
+    "    'time_end': end_date_str,\n",
+    "    'limit': 1000  # Maximum number of records per request\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "id": "586b07ba-5396-4c34-a696-01c8bc3597a0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "729"
+      ]
+     },
+     "execution_count": 91,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Fetch the data\n",
+    "response = requests.get(url, headers=headers, params=params)     \n",
+    "len(response.json())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "id": "953422d0-2e75-4d01-862e-6383df54d9e5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "      Timestamp    Open    High     Low   Close\n",
+      "724  2025-02-06  0.7325  0.7660  0.6978  0.7052\n",
+      "725  2025-02-07  0.7052  0.7532  0.6902  0.7072\n",
+      "726  2025-02-08  0.7072  0.7180  0.6815  0.7005\n",
+      "727  2025-02-09  0.7006  0.7160  0.6503  0.6814\n",
+      "728  2025-02-10  0.6815  0.7177  0.6632  0.7037\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Check for successful response\n",
+    "if response.status_code == 200:\n",
+    "    data = response.json()\n",
+    "\n",
+    "    if data:\n",
+    "        # Convert to DataFrame for better readability\n",
+    "        df = pd.DataFrame(data)\n",
+    "\n",
+    "        df = df[[\"time_period_start\", \"price_open\", \"price_high\", \"price_low\", \"price_close\"]]\n",
+    "        df.columns = [\"Timestamp\", \"Open\", \"High\", \"Low\", \"Close\"]\n",
+    "\n",
+    "        # Convert timestamp to readable format\n",
+    "        df[\"Timestamp\"] = pd.to_datetime(df[\"Timestamp\"]).dt.strftime(\"%Y-%m-%d\")\n",
+    "\n",
+    "        # Display the first few rows of the data\n",
+    "        print(df.tail())\n",
+    "        \n",
+    "        # Convert last 365 days of data into JSON format\n",
+    "        price_history = df.to_dict(orient=\"records\")\n",
+    "       \n",
+    "    else:\n",
+    "        print('No data found for the given period.')\n",
+    "else:\n",
+    "    print(f'Error fetching data: {response.status_code}, {response.text}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "ada5ed4f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def count_tokens(text, model=\"gpt-4o\"):\n",
+    "    encoding = tiktoken.encoding_for_model(model)\n",
+    "    return len(encoding.encode(text))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab47d974",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "  # Construct prompt \n",
+    "\n",
+    "prompt = f\"\"\"\n",
+    "  Given the last 365 days of ${base_data['name']} OHLC data:\n",
+    "\n",
+    "  {json.dumps(price_history, indent=2)}\n",
+    "\n",
+    "  Analyze this data and provide a trading signal (Buy, Sell, or Hold) for today based on the trend and the price action.\n",
+    "  Note that today is {end_date.strftime('%Y-%m-%d')}\n",
+    "  Also, provide short term ,mid term and long term signals.\n",
+    "  \"\"\"\n",
+    "num_tokens = count_tokens(prompt)\n",
+    "print(f\"Estimated Tokens: {num_tokens}\")\n",
+    "\n",
+    "print(prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b40fec12",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "To analyze this data, I'll use a combination of moving averages, relative strength index (RSI), and other technical indicators. Please note that this is a simplified analysis and should not be considered as professional trading advice.\n",
+       "\n",
+       "**Current Data**\n",
+       "\n",
+       "For 2025-02-10, the opening price is not available. However, we can calculate the current prices based on the historical data provided.\n",
+       "\n",
+       "Let's assume the last known close price for 2025-02-09 was $0.6815. For simplicity, let's use this as the opening price for today (2025-02-10).\n",
+       "\n",
+       "**Short-Term Signal**\n",
+       "\n",
+       "For a short-term signal, I'll use a simple moving average crossover system.\n",
+       "\n",
+       "* Short-Term Moving Average (20 days): $0.6922\n",
+       "* Short-Term Moving Average (10 days): $0.6747\n",
+       "\n",
+       "Since the 20-day MA ($0.6922) is above the 10-day MA ($0.6747), we can conclude that **Buy** in this timeframe.\n",
+       "\n",
+       "**Mid-Term Signal**\n",
+       "\n",
+       "For a mid-term signal, I'll use RSI.\n",
+       "\n",
+       "* Current Price: $0.6815\n",
+       "* Overbought Region: 70-80\n",
+       "* Oversold Region: 20-50\n",
+       "\n",
+       "The current price ($0.6815) is at the lower end of the oversold region (20-50), indicating a potential buying opportunity.\n",
+       "\n",
+       "Since RSI values are not provided for the entire dataset, we'll use an RSI value of 30 (midpoint of the low and high values). At $0.6815, RSI is approximately 34.\n",
+       "\n",
+       "* Mid-Term Moving Average: Not available\n",
+       "* Mid-Term Momentum: Rising\n",
+       "\n",
+       "Considering the oversold region and rising momentum, **Hold** is a reasonable mid-term strategy for today.\n",
+       "\n",
+       "**Long-Term Signal**\n",
+       "\n",
+       "For a long-term signal, I'll use the overall trend direction based on historical data.\n",
+       "\n",
+       "The dataset shows an upward trend (average True Range, AtR, value has been increasing). From 2025-02-03 to 2025-02-09, there were 6 consecutive increases in this dataset. That's a strong positive trend.\n",
+       "\n",
+       "Since there are no obvious signs of weakness in the long-term data or divergence with other trends (like 50-day MA), I recommend **Hold** for an extended holding period, keeping an eye on RSI values and adjusting positions as needed to stay ahead of potential price drops.\n",
+       "\n",
+       "**Summary**\n",
+       "\n",
+       "* Short-Term: **Buy**\n",
+       "* Mid-Term: **Hold**\n",
+       "* Long-Term: **Hold**"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def get_response(prompt):\n",
+    "    new_response = ollama.chat.completions.create(model=\"llama3.2\",\n",
+    "    messages=[\n",
+    "        {\"role\": \"system\", \"content\": f\"You are a trading analyst providing Buy/Sell/Hold signals based on ${base_data['name']} price history.Note that today is {end_date.strftime('%Y-%m-%d')}\"},\n",
+    "        {\"role\": \"user\", \"content\": prompt}\n",
+    "    ],\n",
+    "    stream=True,\n",
+    "    max_tokens=5500\n",
+    "    )\n",
+    "    markdown_content = \"\"\n",
+    "    \n",
+    "    # Stream response and accumulate markdown content\n",
+    "    for chunk in new_response:\n",
+    "        content = chunk.choices[0].delta.content or ''\n",
+    "        markdown_content += content\n",
+    "        \n",
+    "        # Clear output and display updated markdown\n",
+    "        display(Markdown(markdown_content), clear=True)\n",
+    "        \n",
+    "        yield content\n",
+    "\n",
+    "# Call the function and consume the generator to start streaming\n",
+    "for _ in get_response(prompt):\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 88,
+   "id": "ba09436c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "# $Cardano Trading Analysis for 2025-02-10\n",
+       "\n",
+       "### **Current Price Analysis**\n",
+       "- **Open:** 0.6815\n",
+       "- **High:** 0.7177\n",
+       "- **Low:** 0.6632\n",
+       "- **Close:** 0.7037\n",
+       "\n",
+       "The price of $Cardano closed 3.59% higher than the previous day's close. This suggests a potential bullish reversal following a downward trend observed over the last few days. However, the volatility in the high-low range reflects uncertainty in the market.\n",
+       "\n",
+       "### **Trend Overview**\n",
+       "- **Short-term:** \n",
+       "  - The recent price action indicates a possible recovery as we see an upward close. The price is currently attempting to break resistance, but the last few days exhibited mixed movements (e.g., a decrease before the recent increase). \n",
+       "- **Mid-term:**\n",
+       "  - Over the past month, $Cardano has experienced significant volatility. While it reached its peak at around 1.079 earlier in January, the subsequent decline indicates selling pressure in the mid-term. A consolidation phase appears as buyers are trying to push the price back up.\n",
+       "- **Long-term:**\n",
+       "  - Over the past year, $Cardano has shown high volatility and a fluctuating price range, but it has generally been trending downwards since its recent highs. \n",
+       "\n",
+       "### **Trading Signals**\n",
+       "- **Short-term Signal:** **Buy**\n",
+       "  - The recent upward price movement along with a closing above 0.7000 indicates potential upward momentum. Short-term traders may consider buying into this recovery signal.\n",
+       "\n",
+       "- **Mid-term Signal:** **Hold**\n",
+       "  - Within the last month, while recovery is in place, it is prudent to wait for confirmation of sustained upward movement before committing larger positions. A hold is advised to monitor the situation.\n",
+       "\n",
+       "- **Long-term Signal:** **Sell**\n",
+       "  - Given that the longer-term trends show a downward trajectory since peaking at higher prices, long-term holders might consider selling or reducing positions, especially if the price fails to stay above recent resistance levels.\n",
+       "\n",
+       "### **Conclusion**\n",
+       "Today’s price action indicates a bullish sentiment in the short term but still reflects uncertainty in the mid and long-term periods. It would be wise for traders to remain cautious and adjust positions as the market dynamics evolve further. Always consider your risk management strategies when deciding to enter or exit positions."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def get_response(prompt):\n",
+    "    new_response = openai.chat.completions.create(model=\"gpt-4o-mini\",\n",
+    "    messages=[\n",
+    "        {\"role\": \"system\", \"content\": f\"You are a trading analyst providing Buy/Sell/Hold signals based on ${base_data['name']} price history. Format your response in markdown.Note that today is {end_date.strftime('%Y-%m-%d')}\"},\n",
+    "        {\"role\": \"user\", \"content\": prompt}\n",
+    "    ],\n",
+    "    stream=True,\n",
+    "    max_tokens=5500\n",
+    "    )\n",
+    "    \n",
+    "    # Initialize markdown cell output\n",
+    "    markdown_content = \"\"\n",
+    "    \n",
+    "    # Stream response and accumulate markdown content\n",
+    "    for chunk in new_response:\n",
+    "        content = chunk.choices[0].delta.content or ''\n",
+    "        markdown_content += content\n",
+    "        \n",
+    "        # Clear output and display updated markdown\n",
+    "        display(Markdown(markdown_content), clear=True)\n",
+    "        \n",
+    "        yield content\n",
+    "\n",
+    "# Call the function and consume the generator to start streaming\n",
+    "for _ in get_response(prompt):\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f52bcc0a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

extras/trading/prototype_trader.ipynb

@@ -0,0 +1,354 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "46d90d45-2d19-49c7-b853-6809dc417ea7",
+   "metadata": {},
+   "source": [
+    "# Extra Project - Trading Code Generator\n",
+    "\n",
+    "This is an example extra project to show fine-tuning in action, and applied to code generation.\n",
+    "\n",
+    "## Project Brief\n",
+    "\n",
+    "Build a prototype LLM that can generate example code to suggest trading decisions to buy or sell stocks!\n",
+    "\n",
+    "I generated test data using frontier models, in the other files in this directory. Use this to train an open source code model.\n",
+    "\n",
+    "In this notebook we generate the dataset; then we move over to Google Colab for the fine-tuning.\n",
+    "\n",
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../../resources.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h2 style=\"color:#f71;\">This project is provided as an extra resource</h2>\n",
+    "            <span style=\"color:#f71;\">It will make most sense after completing Week 7, and might trigger some ideas for your own projects.<br/><br/>\n",
+    "                This is provided without a detailed walk-through; the output from the colab has been saved (see last cell) so you can review the results if you have any problems running yourself.\n",
+    "            </span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>\n",
+    "<table style=\"margin: 0; text-align: left;\">\n",
+    "    <tr>\n",
+    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
+    "            <img src=\"../../important.jpg\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
+    "        </td>\n",
+    "        <td>\n",
+    "            <h2 style=\"color:#900;\">Do not use for actual trading decisions!!</h2>\n",
+    "            <span style=\"color:#900;\">It hopefully goes without saying: this project will generate toy trading code that is over-simplified and untrusted.<br/><br/>Please do not make actual trading decisions based on this!</span>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7e2c4bbb-5e8b-4d84-9997-ecb2c349cf54",
+   "metadata": {},
+   "source": [
+    "## First step - generate training data from examples\n",
+    "\n",
+    "There are 3 sample python files generated (via multiple queries) by GPT-4o, Claude 3 Opus and Gemini 1.5 Pro.  \n",
+    "\n",
+    "This notebook creates training data from these files, then converts to the HuggingFace format and uploads to the hub.\n",
+    "\n",
+    "Afterwards, we will move to Google Colab to fine-tune."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16cf3aa2-f407-4b95-8b9e-c3c586f67835",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import glob\n",
+    "import matplotlib.pyplot as plt\n",
+    "import random\n",
+    "from datasets import Dataset\n",
+    "from dotenv import load_dotenv\n",
+    "from huggingface_hub import login\n",
+    "import transformers\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "375302b6-b6a7-46ea-a74c-c2400dbd8bbe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load environment variables in a file called .env\n",
+    "from datasets import load_dataset, Dataset\n",
+    "load_dotenv()\n",
+    "hf_token = os.getenv('HF_TOKEN')\n",
+    "if hf_token and hf_token.startswith(\"hf_\") and len(hf_token)>5:\n",
+    "    print(\"HuggingFace Token looks good so far\")\n",
+    "else:\n",
+    "    print(\"Potential problem with HuggingFace token - please check your .env file, and see the Troubleshooting notebook for more\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8a0c9fff-9eff-42fd-971b-403c99d9b726",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Constants\n",
+    "\n",
+    "DATASET_NAME = \"trade_code_data\"\n",
+    "BASE_MODEL = \"Qwen/CodeQwen1.5-7B\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "586b07ba-5396-4c34-a696-01c8bc3597a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A utility method to convert the text contents of a file into a list of methods\n",
+    "\n",
+    "def extract_method_bodies(text):\n",
+    "    chunks = text.split('def trade')[1:]\n",
+    "    results = []\n",
+    "    for chunk in chunks:\n",
+    "        lines = chunk.split('\\n')[1:]\n",
+    "        body = '\\n'.join(line for line in lines if line!='\\n')\n",
+    "        results.append(body)\n",
+    "    return results          "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "953422d0-2e75-4d01-862e-6383df54d9e5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Read all .py files and convert into training data\n",
+    "\n",
+    "bodies = []\n",
+    "for filename in glob.glob(\"*.py\"):\n",
+    "    with open(filename, 'r', encoding='utf-8') as file:\n",
+    "        content = file.read()\n",
+    "        extracted = extract_method_bodies(content)\n",
+    "        bodies += extracted\n",
+    "\n",
+    "print(f\"Extracted {len(bodies)} trade method bodies\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "836480e9-ba23-4aa3-a7e2-2666884e9a06",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Let's look at one\n",
+    "\n",
+    "print(random.choice(bodies))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "47b10e7e-a562-4968-af3f-254a9b424ac8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# To visualize the lines of code in each \n",
+    "\n",
+    "%matplotlib inline\n",
+    "fig, ax = plt.subplots(1, 1)\n",
+    "lengths = [len(body.split('\\n')) for body in bodies]\n",
+    "ax.set_xlabel('Lines of code')\n",
+    "ax.set_ylabel('Count of training samples');\n",
+    "_ = ax.hist(lengths, rwidth=0.7, color=\"green\", bins=range(0, max(lengths)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "03b37f62-679e-4c3d-9e5b-5878a82696e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add the prompt to the start of every training example\n",
+    "\n",
+    "prompt = \"\"\"\n",
+    "# tickers is a list of stock tickers\n",
+    "import tickers\n",
+    "\n",
+    "# prices is a dict; the key is a ticker and the value is a list of historic prices, today first\n",
+    "import prices\n",
+    "\n",
+    "# Trade represents a decision to buy or sell a quantity of a ticker\n",
+    "import Trade\n",
+    "\n",
+    "import random\n",
+    "import numpy as np\n",
+    "\n",
+    "def trade():\n",
+    "\"\"\"\n",
+    "\n",
+    "data = [prompt + body for body in bodies]\n",
+    "print(random.choice(data))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "28fdb82f-3864-4023-8263-547d17571a5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Distribution of tokens in our dataset\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)\n",
+    "tokenized_data = [tokenizer.encode(each) for each in data]\n",
+    "token_counts = [len(tokens) for tokens in tokenized_data]\n",
+    "\n",
+    "%matplotlib inline\n",
+    "fig, ax = plt.subplots(1, 1)\n",
+    "ax.set_xlabel('Number of tokens')\n",
+    "ax.set_ylabel('Count of training samples');\n",
+    "_ = ax.hist(token_counts, rwidth=0.7, color=\"purple\", bins=range(0, max(token_counts), 20))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b4eb73b0-88ef-4aeb-8e5b-fe7050109ba0",
+   "metadata": {},
+   "source": [
+    "# Enforcing a maximum token length\n",
+    "\n",
+    "We need to specify a maximum number of tokens when we fine-tune.\n",
+    "\n",
+    "Let's pick a cut-off, and only keep training data points that fit within this number of tokens,"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ffb0d55c-5602-4518-b811-fa385c0959a7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "CUTOFF = 320\n",
+    "truncated = len([tokens for tokens in tokenized_data if len(tokens) > CUTOFF])\n",
+    "percentage = truncated/len(tokenized_data)*100\n",
+    "print(f\"With cutoff at {CUTOFF}, we truncate {truncated} datapoints which is {percentage:.1f}% of the dataset\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7064ef0a-7b07-4f24-a580-cbef2c5e1f2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Let's only keep datapoints that wouldn't get truncated\n",
+    "\n",
+    "filtered_data = [datapoint for datapoint in data if len(tokenizer.encode(datapoint))<=CUTOFF]\n",
+    "print(f\"After e now have {len(filtered_data)} datapoints\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fb2bb067-2bd3-498b-9fc8-5e8186afbe27",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Mix up the data\n",
+    "\n",
+    "random.seed(42)\n",
+    "random.shuffle(filtered_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "26713fb9-765f-4524-b9db-447e97686d1a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# I don't make a Training / Test split - if we had more training data, we would!\n",
+    "\n",
+    "dataset = Dataset.from_dict({'text':filtered_data})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bfabba27-ef47-46a8-a26b-4d650ae3b193",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "login(hf_token)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "55b595cd-2df7-4be4-aec1-0667b17d36f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Push your dataset to your hub\n",
+    "# I've also pushed the data to my account and made it public, which you can use from the colab below\n",
+    "\n",
+    "dataset.push_to_hub(DATASET_NAME, private=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4691a025-9800-4e97-a20f-a65f102401f1",
+   "metadata": {},
+   "source": [
+    "## And now to head over to a Google Colab for fine-tuning in the cloud\n",
+    "\n",
+    "Follow this link for the Colab:\n",
+    "\n",
+    "https://colab.research.google.com/drive/1wry2-4AGw-U7K0LQ_jEgduoTQqVIvo1x?usp=sharing\n",
+    "\n",
+    "I've also saved this Colab with output included, so you can see the results without needing to train if you'd prefer.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "04a6c3e0-a2e6-4115-a01a-45e79dfdb730",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

extras/trading/trades_claude.py

@@ -0,0 +1,725 @@
+# tickers is a list of stock tickers
+import tickers
+
+# prices is a dict; the key is a ticker and the value is a list of historic prices, today first
+import prices
+
+# Trade represents a decision to buy or sell a quantity of a ticker
+import Trade
+
+import random
+import numpy as np
+
+def trade2():
+    # Buy if the current price is lower than the average of the last 5 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] < np.mean(prices[ticker][1:6]):
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade3():
+    # Sell if the current price is higher than the average of the last 10 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] > np.mean(prices[ticker][1:11]):
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade4():
+    # Buy if the current price is the lowest in the last 3 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] == min(prices[ticker][:3]):
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade5():
+    # Sell if the current price is the highest in the last 3 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] == max(prices[ticker][:3]):
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade6():
+    # Buy if the current price is higher than the previous day's price
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] > prices[ticker][1]:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade7():
+    # Sell if the current price is lower than the previous day's price
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] < prices[ticker][1]:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade8():
+    # Buy if the current price is higher than the average of the last 20 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] > np.mean(prices[ticker][1:21]):
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade9():
+    # Sell if the current price is lower than the average of the last 20 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] < np.mean(prices[ticker][1:21]):
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade10():
+    # Buy if the current price is higher than the highest price in the last 5 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] > max(prices[ticker][1:6]):
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade11():
+    # Sell if the current price is lower than the lowest price in the last 5 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] < min(prices[ticker][1:6]):
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade12():
+    # Long/Short: Buy the best-performing stock and sell the worst-performing stock in the last 10 days
+    best_ticker = max(tickers, key=lambda x: (prices[x][0] - prices[x][9]) / prices[x][9])
+    worst_ticker = min(tickers, key=lambda x: (prices[x][0] - prices[x][9]) / prices[x][9])
+    return [Trade(best_ticker, 100), Trade(worst_ticker, -100)]
+
+def trade13():
+    # Buy if the 5-day moving average crosses above the 20-day moving average
+    trades = []
+    for ticker in tickers:
+        if np.mean(prices[ticker][:5]) > np.mean(prices[ticker][:20]) and np.mean(prices[ticker][1:6]) <= np.mean(prices[ticker][1:21]):
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade14():
+    # Sell if the 5-day moving average crosses below the 20-day moving average
+    trades = []
+    for ticker in tickers:
+        if np.mean(prices[ticker][:5]) < np.mean(prices[ticker][:20]) and np.mean(prices[ticker][1:6]) >= np.mean(prices[ticker][1:21]):
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade15():
+    # Buy if the current volume is higher than the average volume of the last 10 days
+    trades = []
+    for ticker in tickers:
+        if volumes[ticker][0] > np.mean(volumes[ticker][1:11]):
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade16():
+    # Sell if the current volume is lower than the average volume of the last 10 days
+    trades = []
+    for ticker in tickers:
+        if volumes[ticker][0] < np.mean(volumes[ticker][1:11]):
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade17():
+    # Long/Short: Buy the stock with the highest relative strength index (RSI) and sell the stock with the lowest RSI
+    rsi = {}
+    for ticker in tickers:
+        gains = [max(prices[ticker][i] - prices[ticker][i+1], 0) for i in range(13)]
+        losses = [max(prices[ticker][i+1] - prices[ticker][i], 0) for i in range(13)]
+        avg_gain = sum(gains) / 14
+        avg_loss = sum(losses) / 14
+        rs = avg_gain / avg_loss if avg_loss > 0 else 100
+        rsi[ticker] = 100 - (100 / (1 + rs))
+    best_ticker = max(tickers, key=lambda x: rsi[x])
+    worst_ticker = min(tickers, key=lambda x: rsi[x])
+    return [Trade(best_ticker, 100), Trade(worst_ticker, -100)]
+
+def trade18():
+    # Buy if the current price is higher than the 50-day moving average and the 50-day moving average is higher than the 200-day moving average
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] > np.mean(prices[ticker][:50]) > np.mean(prices[ticker][:200]):
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade19():
+    # Sell if the current price is lower than the 50-day moving average and the 50-day moving average is lower than the 200-day moving average
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] < np.mean(prices[ticker][:50]) < np.mean(prices[ticker][:200]):
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade20():
+    # Long/Short: Buy the stock with the highest momentum and sell the stock with the lowest momentum
+    momentums = {}
+    for ticker in tickers:
+        momentums[ticker] = prices[ticker][0] - prices[ticker][19]
+    best_ticker = max(tickers, key=lambda x: momentums[x])
+    worst_ticker = min(tickers, key=lambda x: momentums[x])
+    return [Trade(best_ticker, 100), Trade(worst_ticker, -100)]
+
+def trade21():
+    # Buy if the current price is higher than the upper Bollinger Band
+    trades = []
+    for ticker in tickers:
+        sma = np.mean(prices[ticker][:20])
+        std = np.std(prices[ticker][:20])
+        upper_band = sma + 2 * std
+        if prices[ticker][0] > upper_band:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade22():
+    # Sell if the current price is lower than the lower Bollinger Band
+    trades = []
+    for ticker in tickers:
+        sma = np.mean(prices[ticker][:20])
+        std = np.std(prices[ticker][:20])
+        lower_band = sma - 2 * std
+        if prices[ticker][0] < lower_band:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade23():
+    # Buy if the current volatility is higher than the average volatility of the last 10 days
+    trades = []
+    for ticker in tickers:
+        volatility = np.std(prices[ticker][:10])
+        avg_volatility = np.mean([np.std(prices[ticker][i:i+10]) for i in range(10)])
+        if volatility > avg_volatility:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade24():
+    # Sell if the current volatility is lower than the average volatility of the last 10 days
+    trades = []
+    for ticker in tickers:
+        volatility = np.std(prices[ticker][:10])
+        avg_volatility = np.mean([np.std(prices[ticker][i:i+10]) for i in range(10)])
+        if volatility < avg_volatility:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade25():
+    # Long/Short: Buy the stock with the lowest volatility and sell the stock with the highest volatility
+    volatilities = {}
+    for ticker in tickers:
+        volatilities[ticker] = np.std(prices[ticker][:10])
+    best_ticker = min(tickers, key=lambda x: volatilities[x])
+    worst_ticker = max(tickers, key=lambda x: volatilities[x])
+    return [Trade(best_ticker, 100), Trade(worst_ticker, -100)]
+
+def trade26():
+    # Buy if the current price is higher than the 20-day exponential moving average (EMA)
+    trades = []
+    for ticker in tickers:
+        ema = prices[ticker][0]
+        multiplier = 2 / (20 + 1)
+        for i in range(1, 20):
+            ema = (prices[ticker][i] - ema) * multiplier + ema
+        if prices[ticker][0] > ema:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade27():
+    # Sell if the current price is lower than the 20-day exponential moving average (EMA)
+    trades = []
+    for ticker in tickers:
+        ema = prices[ticker][0]
+        multiplier = 2 / (20 + 1)
+        for i in range(1, 20):
+            ema = (prices[ticker][i] - ema) * multiplier + ema
+        if prices[ticker][0] < ema:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade28():
+    # Buy if the current price is higher than the upper Keltner Channel
+    trades = []
+    for ticker in tickers:
+        ema = prices[ticker][0]
+        multiplier = 2 / (20 + 1)
+        for i in range(1, 20):
+            ema = (prices[ticker][i] - ema) * multiplier + ema
+        atr = np.mean([np.max(prices[ticker][i:i+10]) - np.min(prices[ticker][i:i+10]) for i in range(10)])
+        upper_channel = ema + 2 * atr
+        if prices[ticker][0] > upper_channel:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade29():
+    # Sell if the current price is lower than the lower Keltner Channel
+    trades = []
+    for ticker in tickers:
+        ema = prices[ticker][0]
+        multiplier = 2 / (20 + 1)
+        for i in range(1, 20):
+            ema = (prices[ticker][i] - ema) * multiplier + ema
+        atr = np.mean([np.max(prices[ticker][i:i+10]) - np.min(prices[ticker][i:i+10]) for i in range(10)])
+        lower_channel = ema - 2 * atr
+        if prices[ticker][0] < lower_channel:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade30():
+    # Long/Short: Buy the stock with the highest Sharpe ratio and sell the stock with the lowest Sharpe ratio
+    sharpe_ratios = {}
+    for ticker in tickers:
+        returns = [prices[ticker][i] / prices[ticker][i+1] - 1 for i in range(19)]
+        sharpe_ratios[ticker] = np.mean(returns) / np.std(returns)
+    best_ticker = max(tickers, key=lambda x: sharpe_ratios[x])
+    worst_ticker = min(tickers, key=lambda x: sharpe_ratios[x])
+    return [Trade(best_ticker, 100), Trade(worst_ticker, -100)]
+
+def trade31():
+    # Buy if the current price is higher than the Ichimoku Cloud conversion line
+    trades = []
+    for ticker in tickers:
+        conversion_line = (np.max(prices[ticker][:9]) + np.min(prices[ticker][:9])) / 2
+        if prices[ticker][0] > conversion_line:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade32():
+    # Buy if the current price is higher than the price 5 days ago
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] > prices[ticker][4]:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade33():
+    # Sell if the current price is lower than the price 5 days ago
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] < prices[ticker][4]:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade34():
+    # Buy if the current price is the highest in the last 15 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] == max(prices[ticker][:15]):
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade35():
+    # Sell if the current price is the lowest in the last 15 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] == min(prices[ticker][:15]):
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade36():
+    # Buy if the current price is higher than the 10-day simple moving average (SMA)
+    trades = []
+    for ticker in tickers:
+        sma = np.mean(prices[ticker][:10])
+        if prices[ticker][0] > sma:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade37():
+    # Sell if the current price is lower than the 10-day simple moving average (SMA)
+    trades = []
+    for ticker in tickers:
+        sma = np.mean(prices[ticker][:10])
+        if prices[ticker][0] < sma:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade38():
+    # Buy if the current price is higher than the highest price in the last 20 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] > max(prices[ticker][:20]):
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade39():
+    # Sell if the current price is lower than the lowest price in the last 20 days
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] < min(prices[ticker][:20]):
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade40():
+    # Buy if the current price is higher than the 50-day SMA
+    trades = []
+    for ticker in tickers:
+        sma = np.mean(prices[ticker][:50])
+        if prices[ticker][0] > sma:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade41():
+    # Sell if the current price is lower than the 50-day SMA
+    trades = []
+    for ticker in tickers:
+        sma = np.mean(prices[ticker][:50])
+        if prices[ticker][0] < sma:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade42():
+    # Buy if the current price is higher than the previous 2 days (a simple uptrend)
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] > prices[ticker][1] > prices[ticker][2]:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade43():
+    # Sell if the current price is lower than the previous 2 days (a simple downtrend)
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] < prices[ticker][1] < prices[ticker][2]:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade44():
+    # Buy if the current price is higher than the previous day's high (a breakout)
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] > max(prices[ticker][1:2]):
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade45():
+    # Sell if the current price is lower than the previous day's low (a breakdown)
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] < min(prices[ticker][1:2]):
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade46():
+    # Buy if the current price is above the previous day's high and the previous day was a down day (a potential reversal)
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] > max(prices[ticker][1:2]) and prices[ticker][1] < prices[ticker][2]:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade47():
+    # Sell if the current price is below the previous day's low and the previous day was an up day (a potential reversal)
+    trades = []
+    for ticker in tickers:
+        if prices[ticker][0] < min(prices[ticker][1:2]) and prices[ticker][1] > prices[ticker][2]:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade48():
+    # Buy if the current price is above the 5-day SMA and the 5-day SMA is above the 10-day SMA (a bullish crossover)
+    trades = []
+    for ticker in tickers:
+        sma5 = np.mean(prices[ticker][:5])
+        sma10 = np.mean(prices[ticker][:10])
+        if prices[ticker][0] > sma5 > sma10:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade49():
+    # Sell if the current price is below the 5-day SMA and the 5-day SMA is below the 10-day SMA (a bearish crossover)
+    trades = []
+    for ticker in tickers:
+        sma5 = np.mean(prices[ticker][:5])
+        sma10 = np.mean(prices[ticker][:10])
+        if prices[ticker][0] < sma5 < sma10:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade50():
+    # Buy if the current price is above the 50-day SMA and the previous price was below the 50-day SMA (a bullish breakthrough)
+    trades = []
+    for ticker in tickers:
+        sma50 = np.mean(prices[ticker][:50])
+        if prices[ticker][0] > sma50 and prices[ticker][1] < sma50:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade51():
+    # Sell if the current price is below the 50-day SMA and the previous price was above the 50-day SMA (a bearish breakthrough)
+    trades = []
+    for ticker in tickers:
+        sma50 = np.mean(prices[ticker][:50])
+        if prices[ticker][0] < sma50 and prices[ticker][1] > sma50:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade52():
+    # Buy if the current price is more than 2 standard deviations below the 20-day mean (a potential oversold condition)
+    trades = []
+    for ticker in tickers:
+        mean20 = np.mean(prices[ticker][:20])
+        std20 = np.std(prices[ticker][:20])
+        if prices[ticker][0] < mean20 - 2 * std20:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade53():
+    # Sell if the current price is more than 2 standard deviations above the 20-day mean (a potential overbought condition)
+    trades = []
+    for ticker in tickers:
+        mean20 = np.mean(prices[ticker][:20])
+        std20 = np.std(prices[ticker][:20])
+        if prices[ticker][0] > mean20 + 2 * std20:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade54():
+    # Buy if the current price is below the 50-day mean and the 50-day mean is increasing (a potential uptrend)
+    trades = []
+    for ticker in tickers:
+        mean50 = np.mean(prices[ticker][:50])
+        prev_mean50 = np.mean(prices[ticker][1:51])
+        if prices[ticker][0] < mean50 and mean50 > prev_mean50:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade55():
+    # Sell if the current price is above the 50-day mean and the 50-day mean is decreasing (a potential downtrend)
+    trades = []
+    for ticker in tickers:
+        mean50 = np.mean(prices[ticker][:50])
+        prev_mean50 = np.mean(prices[ticker][1:51])
+        if prices[ticker][0] > mean50 and mean50 < prev_mean50:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade56():
+    # Buy if the 5-day mean is above the 50-day mean and the 5-day mean was previously below the 50-day mean (a potential trend change)
+    trades = []
+    for ticker in tickers:
+        mean5 = np.mean(prices[ticker][:5])
+        mean50 = np.mean(prices[ticker][:50])
+        prev_mean5 = np.mean(prices[ticker][1:6])
+        if mean5 > mean50 and prev_mean5 < mean50:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade57():
+    # Sell if the 5-day mean is below the 50-day mean and the 5-day mean was previously above the 50-day mean (a potential trend change)
+    trades = []
+    for ticker in tickers:
+        mean5 = np.mean(prices[ticker][:5])
+        mean50 = np.mean(prices[ticker][:50])
+        prev_mean5 = np.mean(prices[ticker][1:6])
+        if mean5 < mean50 and prev_mean5 > mean50:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade58():
+    # Buy the ticker that has had the largest percent decrease over the last 10 days (a potential mean reversion play)
+    percent_changes = {}
+    for ticker in tickers:
+        percent_changes[ticker] = (prices[ticker][0] - prices[ticker][9]) / prices[ticker][9] * 100
+    worst_ticker = min(tickers, key=lambda x: percent_changes[x])
+    return [Trade(worst_ticker, 100)]
+
+def trade59():
+    # Sell the ticker that has had the largest percent increase over the last 10 days (a potential mean reversion play)
+    percent_changes = {}
+    for ticker in tickers:
+        percent_changes[ticker] = (prices[ticker][0] - prices[ticker][9]) / prices[ticker][9] * 100
+    best_ticker = max(tickers, key=lambda x: percent_changes[x])
+    return [Trade(best_ticker, -100)]
+
+def trade60():
+    # Buy if the current price is above the 200-day mean and the 200-day mean is increasing (a potential long-term uptrend)
+    trades = []
+    for ticker in tickers:
+        mean200 = np.mean(prices[ticker][:200])
+        prev_mean200 = np.mean(prices[ticker][1:201])
+        if prices[ticker][0] > mean200 and mean200 > prev_mean200:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade61():
+    # Sell if the current price is below the 200-day mean and the 200-day mean is decreasing (a potential long-term downtrend)
+    trades = []
+    for ticker in tickers:
+        mean200 = np.mean(prices[ticker][:200])
+        prev_mean200 = np.mean(prices[ticker][1:201])
+        if prices[ticker][0] < mean200 and mean200 < prev_mean200:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade62():
+    # Buy if the stock's return is greater than the market's return over the last 5 days
+    trades = []
+    for ticker in tickers:
+        stock_return = (prices[ticker][0] - prices[ticker][4]) / prices[ticker][4]
+        market_return = (sum(prices[t][0] for t in tickers) - sum(prices[t][4] for t in tickers)) / sum(prices[t][4] for t in tickers)
+        if stock_return > market_return:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade63():
+    # Sell if the stock's return is less than the market's return over the last 5 days
+    trades = []
+    for ticker in tickers:
+        stock_return = (prices[ticker][0] - prices[ticker][4]) / prices[ticker][4]
+        market_return = (sum(prices[t][0] for t in tickers) - sum(prices[t][4] for t in tickers)) / sum(prices[t][4] for t in tickers)
+        if stock_return < market_return:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade64():
+    # Buy the stock with the highest relative strength compared to the market over the last 10 days
+    relative_strengths = {}
+    for ticker in tickers:
+        stock_return = prices[ticker][0] / prices[ticker][9]
+        market_return = sum(prices[t][0] for t in tickers) / sum(prices[t][9] for t in tickers)
+        relative_strengths[ticker] = stock_return / market_return
+    best_ticker = max(tickers, key=lambda x: relative_strengths[x])
+    return [Trade(best_ticker, 100)]
+
+def trade65():
+    # Sell the stock with the lowest relative strength compared to the market over the last 10 days
+    relative_strengths = {}
+    for ticker in tickers:
+        stock_return = prices[ticker][0] / prices[ticker][9]
+        market_return = sum(prices[t][0] for t in tickers) / sum(prices[t][9] for t in tickers)
+        relative_strengths[ticker] = stock_return / market_return
+    worst_ticker = min(tickers, key=lambda x: relative_strengths[x])
+    return [Trade(worst_ticker, -100)]
+
+def trade66():
+    # Buy stocks that have a higher Sharpe ratio than the market over the last 20 days
+    trades = []
+    market_returns = [(sum(prices[t][i] for t in tickers) / sum(prices[t][i+1] for t in tickers)) - 1 for i in range(19)]
+    market_sharpe = np.mean(market_returns) / np.std(market_returns)
+    for ticker in tickers:
+        stock_returns = [(prices[ticker][i] / prices[ticker][i+1]) - 1 for i in range(19)]
+        stock_sharpe = np.mean(stock_returns) / np.std(stock_returns)
+        if stock_sharpe > market_sharpe:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade67():
+    # Sell stocks that have a lower Sharpe ratio than the market over the last 20 days
+    trades = []
+    market_returns = [(sum(prices[t][i] for t in tickers) / sum(prices[t][i+1] for t in tickers)) - 1 for i in range(19)]
+    market_sharpe = np.mean(market_returns) / np.std(market_returns)
+    for ticker in tickers:
+        stock_returns = [(prices[ticker][i] / prices[ticker][i+1]) - 1 for i in range(19)]
+        stock_sharpe = np.mean(stock_returns) / np.std(stock_returns)
+        if stock_sharpe < market_sharpe:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade68():
+    # Buy stocks that have a higher beta than 1 (they move more than the market)
+    trades = []
+    market_returns = [(sum(prices[t][i] for t in tickers) / sum(prices[t][i+1] for t in tickers)) - 1 for i in range(49)]
+    for ticker in tickers:
+        stock_returns = [(prices[ticker][i] / prices[ticker][i+1]) - 1 for i in range(49)]
+        beta = np.cov(stock_returns, market_returns)[0, 1] / np.var(market_returns)
+        if beta > 1:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade69():
+    # Sell stocks that have a lower beta than 1 (they move less than the market)
+    trades = []
+    market_returns = [(sum(prices[t][i] for t in tickers) / sum(prices[t][i+1] for t in tickers)) - 1 for i in range(49)]
+    for ticker in tickers:
+        stock_returns = [(prices[ticker][i] / prices[ticker][i+1]) - 1 for i in range(49)]
+        beta = np.cov(stock_returns, market_returns)[0, 1] / np.var(market_returns)
+        if beta < 1:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade70():
+    # Buy stocks that have a higher percentage of up days than the market over the last 50 days
+    trades = []
+    market_up_days = sum(sum(prices[t][i] for t in tickers) > sum(prices[t][i+1] for t in tickers) for i in range(49))
+    for ticker in tickers:
+        stock_up_days = sum(prices[ticker][i] > prices[ticker][i+1] for i in range(49))
+        if stock_up_days > market_up_days:
+            quantity = random.randrange(1, 100)
+            trades.append(Trade(ticker, quantity))
+    return trades
+
+def trade71():
+    # Sell stocks that have a lower percentage of up days than the market over the last 50 days
+    trades = []
+    market_up_days = sum(sum(prices[t][i] for t in tickers) > sum(prices[t][i+1] for t in tickers) for i in range(49))
+    for ticker in tickers:
+        stock_up_days = sum(prices[ticker][i] > prices[ticker][i+1] for i in range(49))
+        if stock_up_days < market_up_days:
+            quantity = random.randrange(-100, -1)
+            trades.append(Trade(ticker, quantity))
+    return trades

extras/trading/trades_gemini.py

@@ -0,0 +1,534 @@
+# tickers is a list of stock tickers
+import tickers
+
+# prices is a dict; the key is a ticker and the value is a list of historic prices, today first
+import prices
+
+# Trade represents a decision to buy or sell a quantity of a ticker
+import Trade
+
+import random
+import numpy as np
+
+def trade2():
+    # Buy the stock with the highest price today
+    ticker = max(prices, key=lambda t: prices[t][0])  # Find ticker with highest price
+    return [Trade(ticker, random.randrange(1, 10))]   # Buy a small quantity
+
+def trade3():
+    # Sell the stock with the lowest price today
+    ticker = min(prices, key=lambda t: prices[t][0])
+    return [Trade(ticker, random.randrange(-10, -1))] 
+
+def trade4():
+    # Buy the stock with the largest percent increase today
+    changes = {t: (prices[t][0] - prices[t][1]) / prices[t][1] for t in prices}
+    ticker = max(changes, key=changes.get)
+    return [Trade(ticker, random.randrange(1, 10))]
+
+def trade5():
+    # Sell the stock with the largest percent decrease today
+    changes = {t: (prices[t][0] - prices[t][1]) / prices[t][1] for t in prices}
+    ticker = min(changes, key=changes.get)
+    return [Trade(ticker, random.randrange(-10, -1))]
+
+def trade6():
+    # Buy the 3 stocks with the highest moving average over the last 5 days
+    mvgs = {t: np.mean(prices[t][:5]) for t in prices}
+    top_tickers = sorted(mvgs, key=mvgs.get, reverse=True)[:3]
+    return [Trade(t, random.randrange(1, 5)) for t in top_tickers]
+
+def trade7():
+    # Sell the 3 stocks with the lowest moving average over the last 5 days
+    mvgs = {t: np.mean(prices[t][:5]) for t in prices}
+    bottom_tickers = sorted(mvgs, key=mvgs.get)[:3]
+    return [Trade(t, random.randrange(-5, -1)) for t in bottom_tickers]
+
+def trade8():
+    # Randomly buy or sell a single stock based on a coin flip
+    ticker = random.choice(tickers)
+    action = random.choice([-1, 1])  # -1 for sell, 1 for buy
+    return [Trade(ticker, action * random.randrange(1, 10))]
+
+def trade9():
+    # Diversify: Buy a small amount of 5 random stocks
+    chosen_tickers = random.sample(tickers, 5)
+    return [Trade(t, random.randrange(1, 3)) for t in chosen_tickers]
+
+def trade10():
+    # Follow the trend: If the market is up today, buy, else sell
+    market_change = (prices[tickers[0]][0] - prices[tickers[0]][1]) / prices[tickers[0]][1]
+    action = 1 if market_change > 0 else -1
+    ticker = random.choice(tickers)
+    return [Trade(ticker, action * random.randrange(1, 10))]
+
+def trade11():
+    # Mean Reversion: Buy the 2 stocks that fell the most yesterday, hoping they rebound
+    yesterday_changes = {t: (prices[t][1] - prices[t][2]) / prices[t][2] for t in prices}
+    bottom_tickers = sorted(yesterday_changes, key=yesterday_changes.get)[:2]
+    return [Trade(t, random.randrange(1, 5)) for t in bottom_tickers]
+
+def trade12():
+    # Momentum: Short the 2 stocks that rose the most yesterday, expecting a pullback
+    yesterday_changes = {t: (prices[t][1] - prices[t][2]) / prices[t][2] for t in prices}
+    top_tickers = sorted(yesterday_changes, key=yesterday_changes.get, reverse=True)[:2]
+    return [Trade(t, random.randrange(-5, -1)) for t in top_tickers]
+
+def trade13():
+    # Pairs Trading: Long one stock, short another with a similar price history
+    correlations = np.corrcoef([prices[t] for t in tickers])
+    i, j = np.unravel_index(np.argmax(correlations), correlations.shape)
+    return [Trade(tickers[i], 1), Trade(tickers[j], -1)] 
+
+def trade14():
+    # Relative Strength: Go long on the strongest stock, short the weakest
+    performances = {t: (prices[t][0] - prices[t][-1]) / prices[t][-1] for t in prices}
+    strongest = max(performances, key=performances.get)
+    weakest = min(performances, key=performances.get)
+    return [Trade(strongest, 1), Trade(weakest, -1)]
+
+def trade15():
+    # Calendar Spread: Buy this month's option, sell next month's (same strike
+    # This is a simplified representation, as actual option trading is more complex
+    ticker = random.choice(tickers)
+    return [Trade(f"{ticker}_OPT_THIS_MONTH", 1), Trade(f"{ticker}_OPT_NEXT_MONTH", -1)]
+
+def trade16():
+    # Straddle: Buy both a call and put option on the same stock (same strike
+    ticker = random.choice(tickers)
+    strike = prices[ticker][0]  # Use the current price as a simple strike price
+    return [Trade(f"{ticker}_CALL_{strike}", 1), Trade(f"{ticker}_PUT_{strike}", 1)]
+
+def trade17():
+    # Breakout: Buy if a stock breaks above its 52-week high
+    ticker = random.choice(tickers)
+    if prices[ticker][0] > max(prices[ticker]):
+        return [Trade(ticker, random.randrange(1, 10))]
+    else:
+        return [] 
+
+def trade18():
+    # Volatility: If market volatility is high, sell (expecting it to decrease
+    market_volatility = np.std([prices[t][0] / prices[t][1] for t in tickers])
+    if market_volatility > 0.05:  # You'd adjust this threshold based on your risk tolerance
+        ticker = random.choice(tickers)
+        return [Trade(ticker, random.randrange(-10, -1))]
+    else:
+        return []
+
+def trade19():
+    # Golden Cross: Buy if the short-term moving average crosses above the long-term
+    ticker = random.choice(tickers)
+    short_ma = np.mean(prices[ticker][:5])
+    long_ma = np.mean(prices[ticker][:20])
+    if short_ma > long_ma and short_ma - long_ma < 0.01:  # Small margin to avoid false signals
+        return [Trade(ticker, random.randrange(1, 10))]
+    else:
+        return []
+
+def trade20():
+    # Death Cross: Sell if the short-term moving average crosses below the long-term
+    ticker = random.choice(tickers)
+    short_ma = np.mean(prices[ticker][:5])
+    long_ma = np.mean(prices[ticker][:20])
+    if short_ma < long_ma and long_ma - short_ma < 0.01: 
+        return [Trade(ticker, random.randrange(-10, -1))]
+    else:
+        return []
+
+def trade21():
+    # Correlated Pairs Buy: Buy a pair of stocks that have historically moved together
+    correlations = np.corrcoef([prices[t] for t in tickers])
+    i, j = np.unravel_index(np.argmax(correlations), correlations.shape)
+    return [Trade(tickers[i], 1), Trade(tickers[j], 1)]
+
+def trade22():
+    # Correlated Pairs Sell: Sell a pair of stocks that have historically moved together
+    correlations = np.corrcoef([prices[t] for t in tickers])
+    i, j = np.unravel_index(np.argmax(correlations), correlations.shape)
+    return [Trade(tickers[i], -1), Trade(tickers[j], -1)]
+
+def trade23():
+    # Contrarian Pairs Buy: Buy a stock that's down while its correlated pair is up
+    correlations = np.corrcoef([prices[t] for t in tickers])
+    i, j = np.unravel_index(np.argmax(correlations), correlations.shape)
+    if prices[tickers[i]][0] < prices[tickers[i]][1] and prices[tickers[j]][0] > prices[tickers[j]][1]:
+        return [Trade(tickers[i], 1)]
+    else:
+        return []
+
+def trade24():
+    # Contrarian Pairs Sell: Sell a stock that's up while its correlated pair is down
+    correlations = np.corrcoef([prices[t] for t in tickers])
+    i, j = np.unravel_index(np.argmax(correlations), correlations.shape)
+    if prices[tickers[i]][0] > prices[tickers[i]][1] and prices[tickers[j]][0] < prices[tickers[j]][1]:
+        return [Trade(tickers[i], -1)]
+    else:
+        return []
+
+def trade25():
+    # Correlation Reversal: Buy a stock that's recently become less correlated with the market
+    # This is a simplified version, you'd likely use a rolling correlation window
+    market_prices = [prices[t] for t in tickers]
+    correlations_today = np.corrcoef(market_prices)
+    correlations_yesterday = np.corrcoef([p[1:] for p in market_prices])
+    diffs = correlations_today - correlations_yesterday
+    i, j = np.unravel_index(np.argmin(diffs), diffs.shape)
+    if i != j:  # Ensure we're not comparing a stock to itself
+        return [Trade(tickers[i], 1)]
+    else:
+        return []
+
+def trade26():
+    # Sector Rotation: Buy the top 2 stocks from the sector that's most correlated with the market
+    # Assuming you have sector data (e.g., 'sector_map' dict: ticker -> sector)
+    sector_returns = {s: np.mean([(prices[t][0] - prices[t][1]) / prices[t][1] for t in tickers if sector_map[t] == s]) for s in set(sector_map.values())}
+    top_sector = max(sector_returns, key=sector_returns.get)
+    top_tickers_in_sector = sorted([(t, prices[t][0]) for t in tickers if sector_map[t] == top_sector], key=lambda x: x[1], reverse=True)[:2]
+    return [Trade(t, 1) for t, _ in top_tickers_in_sector]
+
+def trade27():
+    # Beta-Weighted Portfolio: Allocate more to stocks with higher betas (more volatile
+    # You'd need historical market data to calculate betas
+    betas = {t: random.uniform(0.5, 2) for t in tickers}  # Placeholder for actual betas
+    total_beta = sum(betas.values())
+    allocations = {t: betas[t] / total_beta * 100 for t in tickers}
+    return [Trade(t, int(allocations[t])) for t in tickers]
+
+def trade28():
+    # Diversified Portfolio: Buy a mix of stocks with low correlations to each other
+    correlations = np.corrcoef([prices[t] for t in tickers])
+    chosen_tickers = []
+    while len(chosen_tickers) < 5 and len(tickers) > 0:
+        t = random.choice(tickers)
+        if all(correlations[tickers.index(t)][tickers.index(c)] < 0.5 for c in chosen_tickers):
+            chosen_tickers.append(t)
+            tickers.remove(t) 
+    return [Trade(t, random.randrange(1, 3)) for t in chosen_tickers]
+
+def trade29():
+    # Cointegration: Find a pair of stocks that are cointegrated and trade their spread
+    # This requires more complex analysis (e.g., using the Johansen test)
+    # For simplicity, we'll just pick a random pair and assume cointegration
+    i, j = random.sample(range(len(tickers)), 2)
+    spread = prices[tickers[i]][0] - prices[tickers[j]][0]
+    if spread > 0:
+        return [Trade(tickers[i], -1), Trade(tickers[j], 1)] 
+    else:
+        return [Trade(tickers[i], 1), Trade(tickers[j], -1)]
+
+def trade30():
+    # Basket Trading: Buy or sell a basket of stocks based on their correlation to a benchmark
+    # You'd need a benchmark ticker and its historical prices
+    benchmark = "SPY"
+    correlations = np.corrcoef([prices[t] for t in tickers + [benchmark]])[:-1, -1]  # Correlate each stock with the benchmark
+    if np.mean(correlations) > 0.5:
+        return [Trade(t, 1) for t in tickers]
+    else:
+        return [Trade(t, -1) for t in tickers]
+
+def trade31():
+    # Double Bottom: Buy when a stock forms a double bottom pattern
+    ticker = random.choice(tickers)
+    if prices[ticker][0] < prices[ticker][2] < prices[ticker][4] and prices[ticker][1] > prices[ticker][3]:
+        return [Trade(ticker, 1)]
+    else:
+        return []
+
+def trade32():
+    # Double Top: Sell when a stock forms a double top pattern
+    ticker = random.choice(tickers)
+    if prices[ticker][0] > prices[ticker][2] > prices[ticker][4] and prices[ticker][1] < prices[ticker][3]:
+        return [Trade(ticker, -1)]
+    else:
+        return []
+
+def trade33():
+    # Head and Shoulders: Sell when a stock forms a head and shoulders pattern
+    ticker = random.choice(tickers)
+    if prices[ticker][0] < prices[ticker][2] < prices[ticker][4] and prices[ticker][1] > prices[ticker][3] > prices[ticker][5]:
+        return [Trade(ticker, -1)]
+    else:
+        return []
+
+def trade34
+    # Inverse Head and Shoulders: Buy when a stock forms an inverse head and shoulders pattern
+    ticker = random.choice(tickers)
+    if prices[ticker][0] > prices[ticker][2] > prices[ticker][4] and prices[ticker][1] < prices[ticker][3] < prices[ticker][5]:
+        return [Trade(ticker, 1)]
+    else:
+        return []
+
+def trade35():
+    # Ascending Triangle: Buy when a stock forms an ascending triangle pattern
+    ticker = random.choice(tickers)
+    # Simplified logic: check for higher lows and flat highs
+    if prices[ticker][0] > prices[ticker][2] > prices[ticker][4] and prices[ticker][1] == prices[ticker][3] == prices[ticker][5]:
+        return [Trade(ticker, 1)]
+    else:
+        return []
+
+def trade36():
+    # Descending Triangle: Sell when a stock forms a descending triangle pattern
+    ticker = random.choice(tickers)
+    # Simplified logic: check for lower highs and flat lows
+    if prices[ticker][0] < prices[ticker][2] < prices[ticker][4] and prices[ticker][1] == prices[ticker][3] == prices[ticker][5]:
+        return [Trade(ticker, -1)]
+    else:
+        return []
+
+def trade37():
+    # Flag/Pennant: Buy or sell based on the direction of the flag/pennant pattern
+    ticker = random.choice(tickers)
+    # Simplified logic: check for a consolidation period after a strong move
+    if abs(prices[ticker][0] - np.mean(prices[ticker][1:5])) < 0.05 and abs(prices[ticker][5] - prices[ticker][6]) > 0.1:
+        # Buy if the prior move was up, sell if down
+        return [Trade(ticker, 1 if prices[ticker][5] > prices[ticker][6] else -1)]
+    else:
+        return []
+
+def trade38():
+    # Gap Up: Buy when a stock opens significantly higher than its previous close
+    ticker = random.choice(tickers)
+    if prices[ticker][0] > prices[ticker][1] * 1.05:  # 5% gap up
+        return [Trade(ticker, 1)]
+    else:
+        return []
+
+def trade39():
+    # Gap Down: Sell when a stock opens significantly lower than its previous close
+    ticker = random.choice(tickers)
+    if prices[ticker][0] < prices[ticker][1] * 0.95:  # 5% gap down
+        return [Trade(ticker, -1)]
+    else:
+        return []
+
+def trade40():
+    # Rounding Bottom: Buy when a stock forms a rounding bottom pattern
+    ticker = random.choice(tickers)
+    # Simplified logic: check for a gradual price increase after a period of decline
+    if prices[ticker][0] > prices[ticker][2] > prices[ticker][4] and prices[ticker][1] < prices[ticker][3] < prices[ticker][5]:
+        return [Trade(ticker, 1)]
+    else:
+        return []
+
+def trade41():
+    # Overbought/Oversold (RSI): Sell if RSI is above 70, buy if below 30
+    ticker = random.choice(tickers)
+    rsi = calculate_rsi(prices[ticker], 14)  # Assuming you have an RSI calculation function
+    if rsi > 70:
+        return [Trade(ticker, -1)]
+    elif rsi < 30:
+        return [Trade(ticker, 1)]
+    else:
+        return []
+
+def trade42():
+    # Bollinger Bands Breakout: Buy if price breaks above the upper band, sell if below lower
+    ticker = random.choice(tickers)
+    upper, middle, lower = calculate_bollinger_bands(prices[ticker], 20, 2)  # Assuming you have a Bollinger Band calculation function
+    if prices[ticker][0] > upper:
+        return [Trade(ticker, 1)]
+    elif prices[ticker][0] < lower:
+        return [Trade(ticker, -1)]
+    else:
+        return []
+
+def trade43():
+    # Channel Breakout: Buy or sell when price breaks out of a recent price channel
+    ticker = random.choice(tickers)
+    highs = [max(prices[ticker][i:i+5]) for i in range(len(prices[ticker]) - 5)]
+    lows = [min(prices[ticker][i:i+5]) for i in range(len(prices[ticker]) - 5)]
+    if prices[ticker][0] > highs[-1]:
+        return [Trade(ticker, 1)]
+    elif prices[ticker][0] < lows[-1]:
+        return [Trade(ticker, -1)]
+    else:
+        return []
+
+def trade44():
+    # Trend Following: Buy if the 20-day moving average is rising, sell if falling
+    ticker = random.choice(tickers)
+    ma20_today = np.mean(prices[ticker][:20])
+    ma20_yesterday = np.mean(prices[ticker][1:21])
+    if ma20_today > ma20_yesterday:
+        return [Trade(ticker, 1)]
+    elif ma20_today < ma20_yesterday:
+        return [Trade(ticker, -1)]
+    else:
+        return []
+
+def trade45():
+    # MACD Crossover: Buy when MACD line crosses above signal line, sell when below
+    ticker = random.choice(tickers)
+    macd_line, signal_line = calculate_macd(prices[ticker])  # Assuming you have a MACD calculation function
+    if macd_line[-1] > signal_line[-1] and macd_line[-2] <= signal_line[-2]:
+        return [Trade(ticker, 1)]
+    elif macd_line[-1] < signal_line[-1] and macd_line[-2] >= signal_line[-2]:
+        return [Trade(ticker, -1)]
+    else:
+        return []
+
+def trade46():
+    # Stochastic Oscillator: Buy if %K crosses above %D in oversold zone, sell if opposite
+    ticker = random.choice(tickers)
+    k_line, d_line = calculate_stochastic(prices[ticker])  # Assuming you have a Stochastic calculation function
+    if k_line[-1] > d_line[-1] and k_line[-1] < 20:
+        return [Trade(ticker, 1)]
+    elif k_line[-1] < d_line[-1] and k_line[-1] > 80:
+        return [Trade(ticker, -1)]
+    else:
+        return []
+
+def trade47():
+    # Volume Spike: Buy if today's volume is much higher than the average
+    # You'd need volume data for this strategy
+    ticker = random.choice(tickers)
+    avg_volume = np.mean(volumes[ticker][1:])  # Assuming you have 'volumes' data
+    if volumes[ticker][0] > avg_volume * 2:
+        return [Trade(ticker, 1)]
+    else:
+        return []
+
+def trade48():
+    # Price Spike: Buy if today's price increase is much higher than average daily change
+    ticker = random.choice(tickers)
+    daily_changes = [(prices[ticker][i] - prices[ticker][i + 1]) / prices[ticker][i + 1] for i in range(len(prices[ticker]) - 1)]
+    avg_change = np.mean(daily_changes)
+    today_change = (prices[ticker][0] - prices[ticker][1]) / prices[ticker][1]
+    if today_change > avg_change * 2:
+        return [Trade(ticker, 1)]
+    else:
+        return []
+
+def trade49():
+    # Mean Reversion (Long-term): Buy if the price is below its 200-day moving average
+    ticker = random.choice(tickers)
+    ma200 = np.mean(prices[ticker])
+    if prices[ticker][0] < ma200:
+        return [Trade(ticker, 1)]
+    else:
+        return []
+
+def trade50():
+    # Trend Reversal (Parabolic SAR): Buy or sell based on the Parabolic SAR indicator
+    # Assuming you have a Parabolic SAR calculation function
+    ticker = random.choice(tickers)
+    sar = calculate_parabolic_sar(prices[ticker])
+    if prices[ticker][0] > sar[-1]: 
+        return [Trade(ticker, 1)]
+    elif prices[ticker][0] < sar[-1]:
+        return [Trade(ticker, -1)]
+    else:
+        return []
+
+def trade51():
+    # Market Outperformance: Buy stocks whose daily returns beat the market
+    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
+    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
+    outperformers = [t for t in tickers if (prices[t][0] - prices[t][1]) / prices[t][1] > market_return]
+    if outperformers:
+        ticker = random.choice(outperformers)
+        return [Trade(ticker, 1)]
+    else:
+        return []
+
+def trade52():
+    # Market Underperformance: Short stocks whose daily returns lag the market
+    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
+    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
+    underperformers = [t for t in tickers if (prices[t][0] - prices[t][1]) / prices[t][1] < market_return]
+    if underperformers:
+        ticker = random.choice(underperformers)
+        return [Trade(ticker, -1)]
+    else:
+        return []
+
+def trade53():
+    # Relative Strength to Market: Buy the stock with the highest relative strength to the market
+    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
+    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
+    relative_strengths = {t: ((prices[t][0] - prices[t][1]) / prices[t][1]) - market_return for t in tickers}
+    ticker = max(relative_strengths, key=relative_strengths.get)
+    return [Trade(ticker, 1)]
+
+def trade54():
+    # Relative Weakness to Market: Short the stock with the lowest relative strength to the market
+    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
+    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
+    relative_strengths = {t: ((prices[t][0] - prices[t][1]) / prices[t][1]) - market_return for t in tickers}
+    ticker = min(relative_strengths, key=relative_strengths.get)
+    return [Trade(ticker, -1)]
+
+def trade55():
+    # Sector vs. Market: Buy top stock from sector outperforming the market, short from underperforming
+    # Assuming you have sector data (e.g., 'sector_map' dict: ticker -> sector)
+    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
+    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
+    sector_returns = {s: np.mean([(prices[t][0] - prices[t][1]) / prices[t][1] for t in tickers if sector_map[t] == s]) for s in set(sector_map.values())}
+    outperforming_sectors = [s for s in sector_returns if sector_returns[s] > market_return]
+    underperforming_sectors = [s for s in sector_returns if sector_returns[s] < market_return]
+    trades = []
+    if outperforming_sectors:
+        top_ticker = max([(t, prices[t][0]) for t in tickers if sector_map[t] == random.choice(outperforming_sectors)], key=lambda x: x[1])[0]
+        trades.append(Trade(top_ticker, 1))
+    if underperforming_sectors:
+        bottom_ticker = min([(t, prices[t][0]) for t in tickers if sector_map[t] == random.choice(underperforming_sectors)], key=lambda x: x[1])[0]
+        trades.append(Trade(bottom_ticker, -1))
+    return trades
+
+def trade56():
+    # Market-Neutral Pairs: Long/short pairs of stocks with similar market betas
+    betas = {t: random.uniform(0.8, 1.2) for t in tickers}  # Placeholder, calculate actual betas
+    pairs = [(t1, t2) for t1 in tickers for t2 in tickers if abs(betas[t1] - betas[t2]) < 0.1 and t1 != t2]
+    if pairs:
+        t1, t2 = random.choice(pairs)
+        return [Trade(t1, 1), Trade(t2, -1)]
+    else:
+        return []
+
+def trade57():
+    # Beta Rotation: Buy high-beta stocks if the market is rising, low-beta if falling
+    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
+    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
+    betas = {t: random.uniform(0.5, 2) for t in tickers}  # Placeholder, calculate actual betas
+    if market_return > 0:  # Market is rising
+        target_beta = 1.5  # Example target for high-beta
+    else:
+        target_beta = 0.8   # Example target for low-beta
+    closest_ticker = min(tickers, key=lambda t: abs(betas[t] - target_beta))
+    return [Trade(closest_ticker, 1 if market_return > 0 else -1)]  # Buy if rising, short if falling
+
+def trade58():
+    # Market Timing with Relative Strength: Buy strong stocks in up markets, sell in down markets
+    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
+    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
+    relative_strengths = {t: ((prices[t][0] - prices[t][-1]) / prices[t][-1]) for t in tickers}  # Calculate over a longer period (e.g., 20 days)
+    if market_return > 0:
+        strongest = max(relative_strengths, key=relative_strengths.get)
+        return [Trade(strongest, 1)]
+    else:
+        weakest = min(relative_strengths, key=relative_strengths.get)
+        return [Trade(weakest, -1)]
+
+def trade59():
+    # Relative Value to Market: Buy stocks trading below their historical average relative to the market
+    # Requires historical data to calculate averages
+    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
+    relative_values = {t: prices[t][0] / total_market_values[0] for t in tickers}  # Current relative value
+    historical_averages = {t: 0.05 for t in tickers}  # Placeholder, calculate actual averages
+    undervalued = [t for t in tickers if relative_values[t] < historical_averages[t] * 0.95]  # Allow some buffer
+    if undervalued:
+        ticker = random.choice(undervalued)
+        return [Trade(ticker, 1)]
+    else:
+        return []
+
+def trade60():
+    # Market-Cap Weighted: Allocate trade amounts proportional to each stock's market cap relative to total market
+    total_market_value = sum(prices[t][0] for t in tickers)
+    market_caps = {t: prices[t][0] * 1000 for t in tickers}  # Assuming 1000 shares outstanding for each stock
+    weights = {t: market_caps[t] / total_market_value for t in tickers}
+    total_trade_amount = 100  # Example
+    trades = [Trade(t, int(weights[t] * total_trade_amount)) for t in tickers]
+    return trades

extras/trading/trades_gpt-4o.py

@@ -0,0 +1,884 @@
+# tickers is a list of stock tickers
+import tickers
+
+# prices is a dict; the key is a ticker and the value is a list of historic prices, today first
+import prices
+
+# Trade represents a decision to buy or sell a quantity of a ticker
+import Trade
+
+import random
+import numpy as np
+
+def trade2():
+    # Buy top performing stock in the last 5 days
+    avg_prices = {ticker: np.mean(prices[ticker][:5]) for ticker in tickers}
+    best_ticker = max(avg_prices, key=avg_prices.get)
+    trade = Trade(best_ticker, 100)
+    return [trade]
+
+def trade3():
+    # Sell worst performing stock in the last 5 days
+    avg_prices = {ticker: np.mean(prices[ticker][:5]) for ticker in tickers}
+    worst_ticker = min(avg_prices, key=avg_prices.get)
+    trade = Trade(worst_ticker, -100)
+    return [trade]
+
+def trade4():
+    # Buy random stock from top 5 performing in the last 10 days
+    avg_prices = {ticker: np.mean(prices[ticker][:10]) for ticker in tickers}
+    top_5_tickers = sorted(avg_prices, key=avg_prices.get, reverse=True)[:5]
+    ticker = random.choice(top_5_tickers)
+    trade = Trade(ticker, 100)
+    return [trade]
+
+def trade5():
+    # Sell random stock from bottom 5 performing in the last 10 days
+    avg_prices = {ticker: np.mean(prices[ticker][:10]) for ticker in tickers}
+    bottom_5_tickers = sorted(avg_prices, key=avg_prices.get)[:5]
+    ticker = random.choice(bottom_5_tickers)
+    trade = Trade(ticker, -100)
+    return [trade]
+
+def trade6():
+    # Buy stocks with a positive trend over the last 7 days
+    trending_up = [ticker for ticker in tickers if prices[ticker][0] > prices[ticker][6]]
+    ticker = random.choice(trending_up)
+    trade = Trade(ticker, 100)
+    return [trade]
+
+def trade7():
+    # Sell stocks with a negative trend over the last 7 days
+    trending_down = [ticker for ticker in tickers if prices[ticker][0] < prices[ticker][6]]
+    ticker = random.choice(trending_down)
+    trade = Trade(ticker, -100)
+    return [trade]
+
+def trade8():
+    # Buy stocks with the lowest volatility over the last 20 days
+    volatilities = {ticker: np.std(prices[ticker][:20]) for ticker in tickers}
+    least_volatile = min(volatilities, key=volatilities.get)
+    trade = Trade(least_volatile, 100)
+    return [trade]
+
+def trade9():
+    # Sell stocks with the highest volatility over the last 20 days
+    volatilities = {ticker: np.std(prices[ticker][:20]) for ticker in tickers}
+    most_volatile = max(volatilities, key=volatilities.get)
+    trade = Trade(most_volatile, -100)
+    return [trade]
+
+def trade10():
+    # Random mixed strategy: randomly buy or sell a random stock
+    ticker = random.choice(tickers)
+    quantity = random.choice([-100, 100])
+    trade = Trade(ticker, quantity)
+    return [trade]
+
+def trade11():
+    # Buy the top 3 performing stocks in the last 15 days
+    avg_prices = {ticker: np.mean(prices[ticker][:15]) for ticker in tickers}
+    top_3_tickers = sorted(avg_prices, key=avg_prices.get, reverse=True)[:3]
+    trades = [Trade(ticker, 100) for ticker in top_3_tickers]
+    return trades
+
+def trade12():
+    # Sell the bottom 3 performing stocks in the last 15 days
+    avg_prices = {ticker: np.mean(prices[ticker][:15]) for ticker in tickers}
+    bottom_3_tickers = sorted(avg_prices, key=avg_prices.get)[:3]
+    trades = [Trade(ticker, -100) for ticker in bottom_3_tickers]
+    return trades
+
+def trade13():
+    # Buy 2 random stocks with the highest increase in price in the last 10 days
+    price_increases = {ticker: prices[ticker][0] - prices[ticker][9] for ticker in tickers}
+    top_2_increases = sorted(price_increases, key=price_increases.get, reverse=True)[:2]
+    trades = [Trade(ticker, 100) for ticker in top_2_increases]
+    return trades
+
+def trade14():
+    # Sell 2 random stocks with the highest decrease in price in the last 10 days
+    price_decreases = {ticker: prices[ticker][0] - prices[ticker][9] for ticker in tickers}
+    top_2_decreases = sorted(price_decreases, key=price_decreases.get)[:2]
+    trades = [Trade(ticker, -100) for ticker in top_2_decreases]
+    return trades
+
+def trade15():
+    # Buy stocks that have shown the highest volatility in the last 30 days
+    volatilities = {ticker: np.std(prices[ticker][:30]) for ticker in tickers}
+    high_volatility_tickers = sorted(volatilities, key=volatilities.get, reverse=True)[:3]
+    trades = [Trade(ticker, 100) for ticker in high_volatility_tickers]
+    return trades
+
+def trade16():
+    # Sell stocks that have shown the lowest volatility in the last 30 days
+    volatilities = {ticker: np.std(prices[ticker][:30]) for ticker in tickers}
+    low_volatility_tickers = sorted(volatilities, key=volatilities.get)[:3]
+    trades = [Trade(ticker, -100) for ticker in low_volatility_tickers]
+    return trades
+
+def trade17():
+    # Buy stocks with prices above their 50-day moving average
+    ma_50 = {ticker: np.mean(prices[ticker][:50]) for ticker in tickers}
+    above_ma_tickers = [ticker for ticker in tickers if prices[ticker][0] > ma_50[ticker]]
+    trades = [Trade(ticker, 100) for ticker in random.sample(above_ma_tickers, min(3, len(above_ma_tickers)))]
+    return trades
+
+def trade18():
+    # Sell stocks with prices below their 50-day moving average
+    ma_50 = {ticker: np.mean(prices[ticker][:50]) for ticker in tickers}
+    below_ma_tickers = [ticker for ticker in tickers if prices[ticker][0] < ma_50[ticker]]
+    trades = [Trade(ticker, -100) for ticker in random.sample(below_ma_tickers, min(3, len(below_ma_tickers)))]
+    return trades
+
+def trade19():
+    # Mixed strategy: buy 2 random stocks and sell 2 random stocks
+    buy_tickers = random.sample(tickers, 2)
+    sell_tickers = random.sample([ticker for ticker in tickers if ticker not in buy_tickers], 2)
+    trades = [Trade(ticker, 100) for ticker in buy_tickers] + [Trade(ticker, -100) for ticker in sell_tickers]
+    return trades
+
+def trade20():
+    # Buy stocks that have positive return in the last 20 days and sell those with negative return
+    returns = {ticker: (prices[ticker][0] - prices[ticker][19]) / prices[ticker][19] for ticker in tickers}
+    buy_tickers = [ticker for ticker in tickers if returns[ticker] > 0]
+    sell_tickers = [ticker for ticker in tickers if returns[ticker] < 0]
+    trades = [Trade(ticker, 100) for ticker in random.sample(buy_tickers, min(2, len(buy_tickers)))] + \
+             [Trade(ticker, -100) for ticker in random.sample(sell_tickers, min(2, len(sell_tickers)))]
+    return trades
+
+def trade21():
+    # Buy the top performing stock in the last 3 days
+    avg_prices = {ticker: np.mean(prices[ticker][:3]) for ticker in tickers}
+    best_ticker = max(avg_prices, key=avg_prices.get)
+    trade = Trade(best_ticker, 100)
+    return [trade]
+
+def trade22():
+    # Sell the worst performing stock in the last 3 days
+    avg_prices = {ticker: np.mean(prices[ticker][:3]) for ticker in tickers}
+    worst_ticker = min(avg_prices, key=avg_prices.get)
+    trade = Trade(worst_ticker, -100)
+    return [trade]
+
+def trade23():
+    # Buy stocks that have not changed price in the last 7 days
+    stable_tickers = [ticker for ticker in tickers if prices[ticker][0] == prices[ticker][6]]
+    trades = [Trade(ticker, 100) for ticker in random.sample(stable_tickers, min(3, len(stable_tickers)))]
+    return trades
+
+def trade24():
+    # Sell stocks that have the smallest price change in the last 5 days
+    smallest_changes = sorted(tickers, key=lambda t: abs(prices[t][0] - prices[t][4]))[:3]
+    trades = [Trade(ticker, -100) for ticker in smallest_changes]
+    return trades
+
+def trade25():
+    # Buy random stocks from the top 10 highest priced stocks
+    highest_priced = sorted(tickers, key=lambda t: prices[t][0], reverse=True)[:10]
+    ticker = random.choice(highest_priced)
+    trade = Trade(ticker, 100)
+    return [trade]
+
+def trade26():
+    # Sell random stocks from the bottom 10 lowest priced stocks
+    lowest_priced = sorted(tickers, key=lambda t: prices[t][0])[:10]
+    ticker = random.choice(lowest_priced)
+    trade = Trade(ticker, -100)
+    return [trade]
+
+def trade27():
+    # Buy 2 stocks with the highest momentum (last 5 days)
+    momentums = {ticker: prices[ticker][0] - prices[ticker][4] for ticker in tickers}
+    top_momentum_tickers = sorted(momentums, key=momentums.get, reverse=True)[:2]
+    trades = [Trade(ticker, 100) for ticker in top_momentum_tickers]
+    return trades
+
+def trade28():
+    # Sell 2 stocks with the lowest momentum (last 5 days)
+    momentums = {ticker: prices[ticker][0] - prices[ticker][4] for ticker in tickers}
+    lowest_momentum_tickers = sorted(momentums, key=momentums.get)[:2]
+    trades = [Trade(ticker, -100) for ticker in lowest_momentum_tickers]
+    return trades
+
+def trade29():
+    # Buy the stock with the highest daily price increase yesterday
+    yesterday_increase = {ticker: prices[ticker][1] - prices[ticker][2] for ticker in tickers}
+    best_yesterday_ticker = max(yesterday_increase, key=yesterday_increase.get)
+    trade = Trade(best_yesterday_ticker, 100)
+    return [trade]
+
+def trade30():
+    # Sell the stock with the highest daily price decrease yesterday
+    yesterday_decrease = {ticker: prices[ticker][1] - prices[ticker][2] for ticker in tickers}
+    worst_yesterday_ticker = min(yesterday_decrease, key=yesterday_decrease.get)
+    trade = Trade(worst_yesterday_ticker, -100)
+    return [trade]
+
+def trade31():
+    # Long/short strategy: Buy the top performing stock and sell the worst performing stock over the last 7 days
+    avg_prices = {ticker: np.mean(prices[ticker][:7]) for ticker in tickers}
+    best_ticker = max(avg_prices, key=avg_prices.get)
+    worst_ticker = min(avg_prices, key=avg_prices.get)
+    trades = [Trade(best_ticker, 100), Trade(worst_ticker, -100)]
+    return trades
+
+def trade32():
+    # Buy stocks that have had a positive return in the last 5 days and sell those with a negative return
+    returns = {ticker: (prices[ticker][0] - prices[ticker][4]) / prices[ticker][4] for ticker in tickers}
+    buy_tickers = [ticker for ticker in tickers if returns[ticker] > 0]
+    sell_tickers = [ticker for ticker in tickers if returns[ticker] < 0]
+    trades = [Trade(ticker, 100) for ticker in random.sample(buy_tickers, min(2, len(buy_tickers)))] + \
+             [Trade(ticker, -100) for ticker in random.sample(sell_tickers, min(2, len(sell_tickers)))]
+    return trades
+
+def trade33():
+    # Buy 2 stocks with the highest price-to-earnings ratio and sell 2 with the lowest
+    pe_ratios = {ticker: random.uniform(10, 30) for ticker in tickers}  # Mock P/E ratios
+    top_pe_tickers = sorted(pe_ratios, key=pe_ratios.get, reverse=True)[:2]
+    low_pe_tickers = sorted(pe_ratios, key=pe_ratios.get)[:2]
+    trades = [Trade(ticker, 100) for ticker in top_pe_tickers] + [Trade(ticker, -100) for ticker in low_pe_tickers]
+    return trades
+
+def trade34():
+    # Buy the stock with the highest volume and sell the one with the lowest volume
+    volumes = {ticker: random.randint(1000, 10000) for ticker in tickers}  # Mock volumes
+    high_volume_ticker = max(volumes, key=volumes.get)
+    low_volume_ticker = min(volumes, key=volumes.get)
+    trades = [Trade(high_volume_ticker, 100), Trade(low_volume_ticker, -100)]
+    return trades
+
+def trade35():
+    # Buy 3 stocks with the highest recent momentum and sell 3 with the lowest recent momentum
+    momentums = {ticker: prices[ticker][0] - prices[ticker][5] for ticker in tickers}
+    top_momentum_tickers = sorted(momentums, key=momentums.get, reverse=True)[:3]
+    low_momentum_tickers = sorted(momentums, key=momentums.get)[:3]
+    trades = [Trade(ticker, 100) for ticker in top_momentum_tickers] + [Trade(ticker, -100) for ticker in low_momentum_tickers]
+    return trades
+
+def trade36():
+    # Buy stocks in the technology sector and sell stocks in the energy sector
+    tech_stocks = random.sample(tickers, 3)  # Mock tech stocks
+    energy_stocks = random.sample(tickers, 3)  # Mock energy stocks
+    trades = [Trade(ticker, 100) for ticker in tech_stocks] + [Trade(ticker, -100) for ticker in energy_stocks]
+    return trades
+
+def trade37():
+    # Long/short strategy: Buy the top 2 stocks with the highest recent gains and sell the top 2 with the highest recent losses
+    recent_gains = {ticker: prices[ticker][0] - prices[ticker][10] for ticker in tickers}
+    top_gainers = sorted(recent_gains, key=recent_gains.get, reverse=True)[:2]
+    top_losers = sorted(recent_gains, key=recent_gains.get)[:2]
+    trades = [Trade(ticker, 100) for ticker in top_gainers] + [Trade(ticker, -100) for ticker in top_losers]
+    return trades
+
+def trade38():
+    # Buy the stocks with the highest dividend yield and sell those with the lowest
+    dividend_yields = {ticker: random.uniform(1, 5) for ticker in tickers}  # Mock dividend yields
+    high_yield_tickers = sorted(dividend_yields, key=dividend_yields.get, reverse=True)[:2]
+    low_yield_tickers = sorted(dividend_yields, key=dividend_yields.get)[:2]
+    trades = [Trade(ticker, 100) for ticker in high_yield_tickers] + [Trade(ticker, -100) for ticker in low_yield_tickers]
+    return trades
+
+def trade39():
+    # Buy stocks that are trading near their 52-week highs and sell those near their 52-week lows
+    highs_52w = {ticker: max(prices[ticker]) for ticker in tickers}
+    lows_52w = {ticker: min(prices[ticker]) for ticker in tickers}
+    near_highs = [ticker for ticker in tickers if prices[ticker][0] >= 0.9 * highs_52w[ticker]]
+    near_lows = [ticker for ticker in tickers if prices[ticker][0] <= 1.1 * lows_52w[ticker]]
+    trades = [Trade(ticker, 100) for ticker in random.sample(near_highs, min(2, len(near_highs)))] + \
+             [Trade(ticker, -100) for ticker in random.sample(near_lows, min(2, len(near_lows)))]
+    return trades
+
+def trade40():
+    # Long/short strategy: Buy 2 random stocks from the top 10 performing sectors and sell 2 from the bottom 10
+    sectors = {ticker: random.choice(['Tech', 'Energy', 'Health', 'Finance', 'Retail']) for ticker in tickers}
+    sector_performance = {sector: random.uniform(-10, 10) for sector in set(sectors.values())}
+    top_sectors = sorted(sector_performance, key=sector_performance.get, reverse=True)[:2]
+    bottom_sectors = sorted(sector_performance, key=sector_performance.get)[:2]
+    buy_tickers = [ticker for ticker in tickers if sectors[ticker] in top_sectors]
+    sell_tickers = [ticker for ticker in tickers if sectors[ticker] in bottom_sectors]
+    trades = [Trade(ticker, 100) for ticker in random.sample(buy_tickers, min(2, len(buy_tickers)))] + \
+             [Trade(ticker, -100) for ticker in random.sample(sell_tickers, min(2, len(sell_tickers)))]
+    return trades
+
+def trade41():
+    # Buy the stock with the highest price increase today
+    price_increases = {ticker: prices[ticker][0] - prices[ticker][1] for ticker in tickers}
+    best_ticker = max(price_increases, key=price_increases.get)
+    trade = Trade(best_ticker, 100)
+    return [trade]
+
+def trade42():
+    # Sell the stock with the highest price decrease today
+    price_decreases = {ticker: prices[ticker][0] - prices[ticker][1] for ticker in tickers}
+    worst_ticker = min(price_decreases, key=price_decreases.get)
+    trade = Trade(worst_ticker, -100)
+    return [trade]
+
+def trade43():
+    # Buy stocks that have had a positive return in the last 3 days
+    returns = {ticker: (prices[ticker][0] - prices[ticker][2]) / prices[ticker][2] for ticker in tickers}
+    buy_tickers = [ticker for ticker in tickers if returns[ticker] > 0]
+    trades = [Trade(ticker, 100) for ticker in random.sample(buy_tickers, min(3, len(buy_tickers)))]
+    return trades
+
+def trade44():
+    # Sell stocks that have had a negative return in the last 3 days
+    returns = {ticker: (prices[ticker][0] - prices[ticker][2]) / prices[ticker][2] for ticker in tickers}
+    sell_tickers = [ticker for ticker in tickers if returns[ticker] < 0]
+    trades = [Trade(ticker, -100) for ticker in random.sample(sell_tickers, min(3, len(sell_tickers)))]
+    return trades
+
+def trade45():
+    # Buy the stock with the highest average return over the last 10 days
+    avg_returns = {ticker: np.mean([(prices[ticker][i] - prices[ticker][i+1]) / prices[ticker][i+1] for i in range(9)]) for ticker in tickers}
+    best_ticker = max(avg_returns, key=avg_returns.get)
+    trade = Trade(best_ticker, 100)
+    return [trade]
+
+def trade46():
+    # Sell the stock with the lowest average return over the last 10 days
+    avg_returns = {ticker: np.mean([(prices[ticker][i] - prices[ticker][i+1]) / prices[ticker][i+1] for i in range(9)]) for ticker in tickers}
+    worst_ticker = min(avg_returns, key=avg_returns.get)
+    trade = Trade(worst_ticker, -100)
+    return [trade]
+
+def trade47():
+    # Buy stocks that are oversold based on RSI (Randomly assigned for simplicity)
+    rsi = {ticker: random.uniform(0, 100) for ticker in tickers}
+    oversold_tickers = [ticker for ticker in tickers if rsi[ticker] < 30]
+    trades = [Trade(ticker, 100) for ticker in random.sample(oversold_tickers, min(3, len(oversold_tickers)))]
+    return trades
+
+def trade48():
+    # Sell stocks that are overbought based on RSI (Randomly assigned for simplicity)
+    rsi = {ticker: random.uniform(0, 100) for ticker in tickers}
+    overbought_tickers = [ticker for ticker in tickers if rsi[ticker] > 70]
+    trades = [Trade(ticker, -100) for ticker in random.sample(overbought_tickers, min(3, len(overbought_tickers)))]
+    return trades
+
+def trade49():
+    # Buy stocks with positive momentum over the last 20 days
+    momentums = {ticker: prices[ticker][0] - prices[ticker][19] for ticker in tickers}
+    positive_momentum_tickers = [ticker for ticker in momentums if momentums[ticker] > 0]
+    trades = [Trade(ticker, 100) for ticker in random.sample(positive_momentum_tickers, min(3, len(positive_momentum_tickers)))]
+    return trades
+
+def trade50():
+    # Sell stocks with negative momentum over the last 20 days
+    momentums = {ticker: prices[ticker][0] - prices[ticker][19] for ticker in tickers}
+    negative_momentum_tickers = [ticker for ticker in momentums if momentums[ticker] < 0]
+    trades = [Trade(ticker, -100) for ticker in random.sample(negative_momentum_tickers, min(3, len(negative_momentum_tickers)))]
+    return trades
+
+def trade51():
+    # Buy stocks that have a high positive correlation with a randomly chosen strong performer
+    import scipy.stats
+    base_ticker = random.choice(tickers)
+    base_prices = prices[base_ticker]
+    correlations = {ticker: scipy.stats.pearsonr(base_prices, prices[ticker])[0] for ticker in tickers if ticker != base_ticker}
+    high_corr_tickers = [ticker for ticker, corr in correlations.items() if corr > 0.8]
+    trades = [Trade(ticker, 100) for ticker in random.sample(high_corr_tickers, min(3, len(high_corr_tickers)))]
+    return trades
+
+def trade52():
+    # Sell stocks that have a high negative correlation with a randomly chosen weak performer
+    import scipy.stats
+    base_ticker = random.choice(tickers)
+    base_prices = prices[base_ticker]
+    correlations = {ticker: scipy.stats.pearsonr(base_prices, prices[ticker])[0] for ticker in tickers if ticker != base_ticker}
+    low_corr_tickers = [ticker for ticker, corr in correlations.items() if corr < -0.8]
+    trades = [Trade(ticker, -100) for ticker in random.sample(low_corr_tickers, min(3, len(low_corr_tickers)))]
+    return trades
+
+def trade53():
+    # Long/short strategy: Buy stocks with high positive correlation and sell stocks with high negative correlation to a strong performer
+    import scipy.stats
+    base_ticker = random.choice(tickers)
+    base_prices = prices[base_ticker]
+    correlations = {ticker: scipy.stats.pearsonr(base_prices, prices[ticker])[0] for ticker in tickers if ticker != base_ticker}
+    high_corr_tickers = [ticker for ticker, corr in correlations.items() if corr > 0.7]
+    low_corr_tickers = [ticker for ticker, corr in correlations.items() if corr < -0.7]
+    trades = [Trade(ticker, 100) for ticker in random.sample(high_corr_tickers, min(2, len(high_corr_tickers)))] + \
+             [Trade(ticker, -100) for ticker in random.sample(low_corr_tickers, min(2, len(low_corr_tickers)))]
+    return trades
+
+def trade54():
+    # Buy stocks that have a high correlation with an index (e.g., S&P 500)
+    import scipy.stats
+    index_prices = [random.uniform(1000, 5000) for _ in range(len(prices[tickers[0]]))]  # Mock index prices
+    correlations = {ticker: scipy.stats.pearsonr(index_prices, prices[ticker])[0] for ticker in tickers}
+    high_corr_tickers = [ticker for ticker, corr in correlations.items() if corr > 0.8]
+    trades = [Trade(ticker, 100) for ticker in random.sample(high_corr_tickers, min(3, len(high_corr_tickers)))]
+    return trades
+
+def trade55():
+    # Sell stocks that have a low correlation with an index (e.g., S&P 500)
+    import scipy.stats
+    index_prices = [random.uniform(1000, 5000) for _ in range(len(prices[tickers[0]]))]  # Mock index prices
+    correlations = {ticker: scipy.stats.pearsonr(index_prices, prices[ticker])[0] for ticker in tickers}
+    low_corr_tickers = [ticker for ticker, corr in correlations.items() if corr < 0.2]
+    trades = [Trade(ticker, -100) for ticker in random.sample(low_corr_tickers, min(3, len(low_corr_tickers)))]
+    return trades
+
+def trade56():
+    # Long/short strategy: Buy stocks with high correlation and sell stocks with low correlation to a randomly chosen strong performer
+    import scipy.stats
+    base_ticker = random.choice(tickers)
+    base_prices = prices[base_ticker]
+    correlations = {ticker: scipy.stats.pearsonr(base_prices, prices[ticker])[0] for ticker in tickers if ticker != base_ticker}
+    high_corr_tickers = [ticker for ticker, corr in correlations.items() if corr > 0.7]
+    low_corr_tickers = [ticker for ticker, corr in correlations.items() if corr < 0.2]
+    trades = [Trade(ticker, 100) for ticker in random.sample(high_corr_tickers, min(2, len(high_corr_tickers)))] + \
+             [Trade(ticker, -100) for ticker in random.sample(low_corr_tickers, min(2, len(low_corr_tickers)))]
+    return trades
+
+def trade57():
+    # Buy stocks that are inversely correlated with a major sector ETF (mocked data)
+    import scipy.stats
+    sector_etf_prices = [random.uniform(50, 150) for _ in range(len(prices[tickers[0]]))]  # Mock sector ETF prices
+    correlations = {ticker: scipy.stats.pearsonr(sector_etf_prices, prices[ticker])[0] for ticker in tickers}
+    inverse_corr_tickers = [ticker for ticker, corr in correlations.items() if corr < -0.7]
+    trades = [Trade(ticker, 100) for ticker in random.sample(inverse_corr_tickers, min(3, len(inverse_corr_tickers)))]
+    return trades
+
+def trade58():
+    # Sell stocks that are highly correlated with a volatile index
+    import scipy.stats
+    volatile_index_prices = [random.uniform(1000, 2000) for _ in range(len(prices[tickers[0]]))]  # Mock volatile index prices
+    correlations = {ticker: scipy.stats.pearsonr(volatile_index_prices, prices[ticker])[0] for ticker in tickers}
+    high_corr_tickers = [ticker for ticker, corr in correlations.items() if corr > 0.8]
+    trades = [Trade(ticker, -100) for ticker in random.sample(high_corr_tickers, min(3, len(high_corr_tickers)))]
+    return trades
+
+def trade59():
+    # Buy stocks that are less correlated with the overall market (S&P 500)
+    import scipy.stats
+    market_prices = [random.uniform(1000, 5000) for _ in range(len(prices[tickers[0]]))]  # Mock market index prices
+    correlations = {ticker: scipy.stats.pearsonr(market_prices, prices[ticker])[0] for ticker in tickers}
+    low_corr_tickers = [ticker for ticker, corr in correlations.items() if corr < 0.3]
+    trades = [Trade(ticker, 100) for ticker in random.sample(low_corr_tickers, min(3, len(low_corr_tickers)))]
+    return trades
+
+def trade60():
+    # Sell stocks that are highly correlated with a specific commodity price (e.g., oil)
+    import scipy.stats
+    commodity_prices = [random.uniform(50, 100) for _ in range(len(prices[tickers[0]]))]  # Mock commodity prices
+    correlations = {ticker: scipy.stats.pearsonr(commodity_prices, prices[ticker])[0] for ticker in tickers}
+    high_corr_tickers = [ticker for ticker, corr in correlations.items() if corr > 0.7]
+    trades = [Trade(ticker, -100) for ticker in random.sample(high_corr_tickers, min(3, len(high_corr_tickers)))]
+    return trades
+
+def trade61():
+    # Buy stocks forming a "double bottom" pattern (last 5 days)
+    double_bottom_tickers = [ticker for ticker in tickers if prices[ticker][4] < prices[ticker][2] == prices[ticker][0] < prices[ticker][1] and prices[ticker][3] > prices[ticker][2]]
+    trades = [Trade(ticker, 100) for ticker in random.sample(double_bottom_tickers, min(3, len(double_bottom_tickers)))]
+    return trades
+
+def trade62():
+    # Sell stocks forming a "double top" pattern (last 5 days)
+    double_top_tickers = [ticker for ticker in tickers if prices[ticker][4] > prices[ticker][2] == prices[ticker][0] > prices[ticker][1] and prices[ticker][3] < prices[ticker][2]]
+    trades = [Trade(ticker, -100) for ticker in random.sample(double_top_tickers, min(3, len(double_top_tickers)))]
+    return trades
+
+def trade63():
+    # Buy stocks showing a "head and shoulders" bottom pattern (last 7 days)
+    hs_bottom_tickers = [ticker for ticker in tickers if prices[ticker][6] > prices[ticker][5] < prices[ticker][4] > prices[ticker][3] < prices[ticker][2] and prices[ticker][1] < prices[ticker][0]]
+    trades = [Trade(ticker, 100) for ticker in random.sample(hs_bottom_tickers, min(3, len(hs_bottom_tickers)))]
+    return trades
+
+def trade64():
+    # Sell stocks showing a "head and shoulders" top pattern (last 7 days)
+    hs_top_tickers = [ticker for ticker in tickers if prices[ticker][6] < prices[ticker][5] > prices[ticker][4] < prices[ticker][3] > prices[ticker][2] and prices[ticker][1] > prices[ticker][0]]
+    trades = [Trade(ticker, -100) for ticker in random.sample(hs_top_tickers, min(3, len(hs_top_tickers)))]
+    return trades
+
+def trade65():
+    # Buy stocks forming a "bullish flag" pattern (last 10 days)
+    bullish_flag_tickers = [ticker for ticker in tickers if prices[ticker][9] < prices[ticker][8] and all(prices[ticker][i] < prices[ticker][i+1] for i in range(8, 4, -1)) and all(prices[ticker][i] > prices[ticker][i+1] for i in range(4, 0, -1))]
+    trades = [Trade(ticker, 100) for ticker in random.sample(bullish_flag_tickers, min(3, len(bullish_flag_tickers)))]
+    return trades
+
+def trade66():
+    # Sell stocks forming a "bearish flag" pattern (last 10 days)
+    bearish_flag_tickers = [ticker for ticker in tickers if prices[ticker][9] > prices[ticker][8] and all(prices[ticker][i] > prices[ticker][i+1] for i in range(8, 4, -1)) and all(prices[ticker][i] < prices[ticker][i+1] for i in range(4, 0, -1))]
+    trades = [Trade(ticker, -100) for ticker in random.sample(bearish_flag_tickers, min(3, len(bearish_flag_tickers)))]
+    return trades
+
+def trade67():
+    # Buy stocks forming a "ascending triangle" pattern (last 15 days)
+    ascending_triangle_tickers = [ticker for ticker in tickers if prices[ticker][14] < prices[ticker][13] and prices[ticker][0] > prices[ticker][7] and all(prices[ticker][i] <= prices[ticker][i+1] for i in range(13))]
+    trades = [Trade(ticker, 100) for ticker in random.sample(ascending_triangle_tickers, min(3, len(ascending_triangle_tickers)))]
+    return trades
+
+def trade68():
+    # Sell stocks forming a "descending triangle" pattern (last 15 days)
+    descending_triangle_tickers = [ticker for ticker in tickers if prices[ticker][14] > prices[ticker][13] and prices[ticker][0] < prices[ticker][7] and all(prices[ticker][i] >= prices[ticker][i+1] for i in range(13))]
+    trades = [Trade(ticker, -100) for ticker in random.sample(descending_triangle_tickers, min(3, len(descending_triangle_tickers)))]
+    return trades
+
+def trade69():
+    # Buy stocks forming a "rounding bottom" pattern (last 20 days)
+    rounding_bottom_tickers = [ticker for ticker in tickers if all(prices[ticker][i] >= prices[ticker][i+1] for i in range(10)) and all(prices[ticker][i] <= prices[ticker][i+1] for i in range(10, 19))]
+    trades = [Trade(ticker, 100) for ticker in random.sample(rounding_bottom_tickers, min(3, len(rounding_bottom_tickers)))]
+    return trades
+
+def trade70():
+    # Sell stocks forming a "rounding top" pattern (last 20 days)
+    rounding_top_tickers = [ticker for ticker in tickers if all(prices[ticker][i] <= prices[ticker][i+1] for i in range(10)) and all(prices[ticker][i] >= prices[ticker][i+1] for i in range(10, 19))]
+    trades = [Trade(ticker, -100) for ticker in random.sample(rounding_top_tickers, min(3, len(rounding_top_tickers)))]
+    return trades
+
+def trade71():
+    # Buy stocks showing a strong upward trend over the last 10 days
+    upward_trend_tickers = [ticker for ticker in tickers if prices[ticker][0] > prices[ticker][9] and all(prices[ticker][i] >= prices[ticker][i+1] for i in range(9))]
+    trades = [Trade(ticker, 100) for ticker in random.sample(upward_trend_tickers, min(3, len(upward_trend_tickers)))]
+    return trades
+
+def trade72():
+    # Sell stocks showing a strong downward trend over the last 10 days
+    downward_trend_tickers = [ticker for ticker in tickers if prices[ticker][0] < prices[ticker][9] and all(prices[ticker][i] <= prices[ticker][i+1] for i in range(9))]
+    trades = [Trade(ticker, -100) for ticker in random.sample(downward_trend_tickers, min(3, len(downward_trend_tickers)))]
+    return trades
+
+def trade73():
+    # Buy stocks that have reverted to their mean price over the last 20 days
+    mean_reversion_tickers = [ticker for ticker in tickers if abs(prices[ticker][0] - np.mean(prices[ticker][:20])) < np.std(prices[ticker][:20])]
+    trades = [Trade(ticker, 100) for ticker in random.sample(mean_reversion_tickers, min(3, len(mean_reversion_tickers)))]
+    return trades
+
+def trade74():
+    # Sell stocks that have deviated significantly from their mean price over the last 20 days
+    mean_deviation_tickers = [ticker for ticker in tickers if abs(prices[ticker][0] - np.mean(prices[ticker][:20])) > 2 * np.std(prices[ticker][:20])]
+    trades = [Trade(ticker, -100) for ticker in random.sample(mean_deviation_tickers, min(3, len(mean_deviation_tickers)))]
+    return trades
+
+def trade75():
+    # Buy stocks that have shown increased volatility in the last 10 days compared to the previous 20 days
+    increased_volatility_tickers = [ticker for ticker in tickers if np.std(prices[ticker][:10]) > 1.5 * np.std(prices[ticker][10:30])]
+    trades = [Trade(ticker, 100) for ticker in random.sample(increased_volatility_tickers, min(3, len(increased_volatility_tickers)))]
+    return trades
+
+def trade76():
+    # Sell stocks that have shown decreased volatility in the last 10 days compared to the previous 20 days
+    decreased_volatility_tickers = [ticker for ticker in tickers if np.std(prices[ticker][:10]) < 0.5 * np.std(prices[ticker][10:30])]
+    trades = [Trade(ticker, -100) for ticker in random.sample(decreased_volatility_tickers, min(3, len(decreased_volatility_tickers)))]
+    return trades
+
+def trade77():
+    # Buy stocks that have broken above their previous 50-day high
+    previous_50_day_highs = {ticker: max(prices[ticker][1:51]) for ticker in tickers}
+    breakout_tickers = [ticker for ticker in tickers if prices[ticker][0] > previous_50_day_highs[ticker]]
+    trades = [Trade(ticker, 100) for ticker in random.sample(breakout_tickers, min(3, len(breakout_tickers)))]
+    return trades
+
+def trade78():
+    # Sell stocks that have broken below their previous 50-day low
+    previous_50_day_lows = {ticker: min(prices[ticker][1:51]) for ticker in tickers}
+    breakdown_tickers = [ticker for ticker in tickers if prices[ticker][0] < previous_50_day_lows[ticker]]
+    trades = [Trade(ticker, -100) for ticker in random.sample(breakdown_tickers, min(3, len(breakdown_tickers)))]
+    return trades
+
+def trade79():
+    # Buy stocks that have shown a significant upward price spike in the last 3 days
+    price_spike_tickers = [ticker for ticker in tickers if (prices[ticker][0] - prices[ticker][2]) / prices[ticker][2] > 0.1]
+    trades = [Trade(ticker, 100) for ticker in random.sample(price_spike_tickers, min(3, len(price_spike_tickers)))]
+    return trades
+
+def trade80():
+    # Sell stocks that have shown a significant downward price spike in the last 3 days
+    price_drop_tickers = [ticker for ticker in tickers if (prices[ticker][0] - prices[ticker][2]) / prices[ticker][2] < -0.1]
+    trades = [Trade(ticker, -100) for ticker in random.sample(price_drop_tickers, min(3, len(price_drop_tickers)))]
+    return trades
+
+def trade81():
+    # Buy stocks that have formed a "golden cross" (50-day MA crosses above 200-day MA)
+    golden_cross_tickers = [ticker for ticker in tickers if np.mean(prices[ticker][:50]) > np.mean(prices[ticker][:200])]
+    trades = [Trade(ticker, 100) for ticker in random.sample(golden_cross_tickers, min(3, len(golden_cross_tickers)))]
+    return trades
+
+def trade82():
+    # Sell stocks that have formed a "death cross" (50-day MA crosses below 200-day MA)
+    death_cross_tickers = [ticker for ticker in tickers if np.mean(prices[ticker][:50]) < np.mean(prices[ticker][:200])]
+    trades = [Trade(ticker, -100) for ticker in random.sample(death_cross_tickers, min(3, len(death_cross_tickers)))]
+    return trades
+
+def trade83():
+    # Buy stocks that have shown an increase in trading volume in the last 5 days
+    volume_increase_tickers = [ticker for ticker in tickers if np.mean(prices[ticker][:5]) > 1.2 * np.mean(prices[ticker][5:10])]
+    trades = [Trade(ticker, 100) for ticker in random.sample(volume_increase_tickers, min(3, len(volume_increase_tickers)))]
+    return trades
+
+def trade84():
+    # Sell stocks that have shown a decrease in trading volume in the last 5 days
+    volume_decrease_tickers = [ticker for ticker in tickers if np.mean(prices[ticker][:5]) < 0.8 * np.mean(prices[ticker][5:10])]
+    trades = [Trade(ticker, -100) for ticker in random.sample(volume_decrease_tickers, min(3, len(volume_decrease_tickers)))]
+    return trades
+
+def trade85():
+    # Buy stocks that have shown consistent daily gains for the last 5 days
+    consistent_gainers = [ticker for ticker in tickers if all(prices[ticker][i] > prices[ticker][i+1] for i in range(5))]
+    trades = [Trade(ticker, 100) for ticker in random.sample(consistent_gainers, min(3, len(consistent_gainers)))]
+    return trades
+
+def trade86():
+    # Sell stocks that have shown consistent daily losses for the last 5 days
+    consistent_losers = [ticker for ticker in tickers if all(prices[ticker][i] < prices[ticker][i+1] for i in range(5))]
+    trades = [Trade(ticker, -100) for ticker in random.sample(consistent_losers, min(3, len(consistent_losers)))]
+    return trades
+
+def trade87():
+    # Buy stocks that are trading near their all-time highs
+    all_time_high_tickers = [ticker for ticker in tickers if prices[ticker][0] >= 0.95 * max(prices[ticker])]
+    trades = [Trade(ticker, 100) for ticker in random.sample(all_time_high_tickers, min(3, len(all_time_high_tickers)))]
+    return trades
+
+def trade88():
+    # Sell stocks that are trading near their all-time lows
+    all_time_low_tickers = [ticker for ticker in tickers if prices[ticker][0] <= 1.05 * min(prices[ticker])]
+    trades = [Trade(ticker, -100) for ticker in random.sample(all_time_low_tickers, min(3, len(all_time_low_tickers)))]
+    return trades
+
+def trade89():
+    # Buy stocks that have gapped up at market open today
+    gap_up_tickers = [ticker for ticker in tickers if prices[ticker][0] > 1.05 * prices[ticker][1]]
+    trades = [Trade(ticker, 100) for ticker in random.sample(gap_up_tickers, min(3, len(gap_up_tickers)))]
+    return trades
+
+def trade90():
+    # Sell stocks that have gapped down at market open today
+    gap_down_tickers = [ticker for ticker in tickers if prices[ticker][0] < 0.95 * prices[ticker][1]]
+    trades = [Trade(ticker, -100) for ticker in random.sample(gap_down_tickers, min(3, len(gap_down_tickers)))]
+    return trades
+
+def trade91():
+    # Buy stocks that have shown a steady upward trend for the last 15 days
+    steady_uptrend_tickers = [ticker for ticker in tickers if all(prices[ticker][i] >= prices[ticker][i+1] for i in range(15))]
+    trades = [Trade(ticker, 100) for ticker in random.sample(steady_uptrend_tickers, min(3, len(steady_uptrend_tickers)))]
+    return trades
+
+def trade92():
+    # Sell stocks that have shown a steady downward trend for the last 15 days
+    steady_downtrend_tickers = [ticker for ticker in tickers if all(prices[ticker][i] <= prices[ticker][i+1] for i in range(15))]
+    trades = [Trade(ticker, -100) for ticker in random.sample(steady_downtrend_tickers, min(3, len(steady_downtrend_tickers)))]
+    return trades
+
+def trade93():
+    # Buy stocks that have outperformed the market index by 5% in the last 30 days
+    market_index_return = random.uniform(-0.05, 0.05)  # Mock market index return
+    outperforming_tickers = [ticker for ticker in tickers if (prices[ticker][0] - prices[ticker][29]) / prices[ticker][29] > market_index_return + 0.05]
+    trades = [Trade(ticker, 100) for ticker in random.sample(outperforming_tickers, min(3, len(outperforming_tickers)))]
+    return trades
+
+def trade94():
+    # Sell stocks that have underperformed the market index by 5% in the last 30 days
+    market_index_return = random.uniform(-0.05, 0.05)  # Mock market index return
+    underperforming_tickers = [ticker for ticker in tickers if (prices[ticker][0] - prices[ticker][29]) / prices[ticker][29] < market_index_return - 0.05]
+    trades = [Trade(ticker, -100) for ticker in random.sample(underperforming_tickers, min(3, len(underperforming_tickers)))]
+    return trades
+
+def trade95():
+    # Buy stocks that have broken above their previous 10-day high
+    previous_10_day_highs = {ticker: max(prices[ticker][1:11]) for ticker in tickers}
+    breakout_tickers = [ticker for ticker in tickers if prices[ticker][0] > previous_10_day_highs[ticker]]
+    trades = [Trade(ticker, 100) for ticker in random.sample(breakout_tickers, min(3, len(breakout_tickers)))]
+    return trades
+
+def trade96():
+    # Sell stocks that have broken below their previous 10-day low
+    previous_10_day_lows = {ticker: min(prices[ticker][1:11]) for ticker in tickers}
+    breakdown_tickers = [ticker for ticker in tickers if prices[ticker][0] < previous_10_day_lows[ticker]]
+    trades = [Trade(ticker, -100) for ticker in random.sample(breakdown_tickers, min(3, len(breakdown_tickers)))]
+    return trades
+
+def trade97():
+    # Buy stocks with a relative strength index (RSI) below 30 (oversold)
+    rsi = {ticker: random.uniform(0, 100) for ticker in tickers}  # Mock RSI values
+    oversold_tickers = [ticker for ticker in tickers if rsi[ticker] < 30]
+    trades = [Trade(ticker, 100) for ticker in random.sample(oversold_tickers, min(3, len(oversold_tickers)))]
+    return trades
+
+def trade98():
+    # Sell stocks with a relative strength index (RSI) above 70 (overbought)
+    rsi = {ticker: random.uniform(0, 100) for ticker in tickers}  # Mock RSI values
+    overbought_tickers = [ticker for ticker in tickers if rsi[ticker] > 70]
+    trades = [Trade(ticker, -100) for ticker in random.sample(overbought_tickers, min(3, len(overbought_tickers)))]
+    return trades
+
+def trade99():
+    # Buy stocks with a price-to-earnings ratio (P/E) below the industry average (mocked data)
+    pe_ratios = {ticker: random.uniform(10, 30) for ticker in tickers}  # Mock P/E ratios
+    industry_average_pe = 20  # Mock industry average P/E
+    undervalued_tickers = [ticker for ticker in tickers if pe_ratios[ticker] < industry_average_pe]
+    trades = [Trade(ticker, 100) for ticker in random.sample(undervalued_tickers, min(3, len(undervalued_tickers)))]
+    return trades
+
+def trade100():
+    # Sell stocks with a price-to-earnings ratio (P/E) above the industry average (mocked data)
+    pe_ratios = {ticker: random.uniform(10, 30) for ticker in tickers}  # Mock P/E ratios
+    industry_average_pe = 20  # Mock industry average P/E
+    overvalued_tickers = [ticker for ticker in tickers if pe_ratios[ticker] > industry_average_pe]
+    trades = [Trade(ticker, -100) for ticker in random.sample(overvalued_tickers, min(3, len(overvalued_tickers)))]
+    return trades
+
+def trade101():
+    # Buy stocks that have outperformed the market by more than 5% in the last 10 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(10)]
+    market_return = (market_total[0] - market_total[-1]) / market_total[-1]
+    outperforming_tickers = [ticker for ticker in tickers if (prices[ticker][0] - prices[ticker][9]) / prices[ticker][9] > market_return + 0.05]
+    trades = [Trade(ticker, 100) for ticker in random.sample(outperforming_tickers, min(3, len(outperforming_tickers)))]
+    return trades
+
+def trade102():
+    # Sell stocks that have underperformed the market by more than 5% in the last 10 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(10)]
+    market_return = (market_total[0] - market_total[-1]) / market_total[-1]
+    underperforming_tickers = [ticker for ticker in tickers if (prices[ticker][0] - prices[ticker][9]) / prices[ticker][9] < market_return - 0.05]
+    trades = [Trade(ticker, -100) for ticker in random.sample(underperforming_tickers, min(3, len(underperforming_tickers)))]
+    return trades
+
+def trade103():
+    # Buy stocks that have shown a positive return while the market showed a negative return over the last 5 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(5)]
+    market_return = (market_total[0] - market_total[-1]) / market_total[-1]
+    positive_tickers = [ticker for ticker in tickers if (prices[ticker][0] - prices[ticker][4]) / prices[ticker][4] > 0 and market_return < 0]
+    trades = [Trade(ticker, 100) for ticker in random.sample(positive_tickers, min(3, len(positive_tickers)))]
+    return trades
+
+def trade104():
+    # Sell stocks that have shown a negative return while the market showed a positive return over the last 5 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(5)]
+    market_return = (market_total[0] - market_total[-1]) / market_total[-1]
+    negative_tickers = [ticker for ticker in tickers if (prices[ticker][0] - prices[ticker][4]) / prices[ticker][4] < 0 and market_return > 0]
+    trades = [Trade(ticker, -100) for ticker in random.sample(negative_tickers, min(3, len(negative_tickers)))]
+    return trades
+
+def trade105():
+    # Buy stocks that have shown less volatility compared to the market over the last 20 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(20)]
+    market_volatility = np.std(market_total)
+    low_volatility_tickers = [ticker for ticker in tickers if np.std(prices[ticker][:20]) < market_volatility]
+    trades = [Trade(ticker, 100) for ticker in random.sample(low_volatility_tickers, min(3, len(low_volatility_tickers)))]
+    return trades
+
+def trade106():
+    # Sell stocks that have shown more volatility compared to the market over the last 20 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(20)]
+    market_volatility = np.std(market_total)
+    high_volatility_tickers = [ticker for ticker in tickers if np.std(prices[ticker][:20]) > market_volatility]
+    trades = [Trade(ticker, -100) for ticker in random.sample(high_volatility_tickers, min(3, len(high_volatility_tickers)))]
+    return trades
+
+def trade107():
+    # Buy stocks that have shown an increasing trend while the market showed a decreasing trend over the last 15 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(15)]
+    market_trend = market_total[0] > market_total[-1]
+    increasing_tickers = [ticker for ticker in tickers if prices[ticker][0] > prices[ticker][14] and not market_trend]
+    trades = [Trade(ticker, 100) for ticker in random.sample(increasing_tickers, min(3, len(increasing_tickers)))]
+    return trades
+
+def trade108():
+    # Sell stocks that have shown a decreasing trend while the market showed an increasing trend over the last 15 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(15)]
+    market_trend = market_total[0] < market_total[-1]
+    decreasing_tickers = [ticker for ticker in tickers if prices[ticker][0] < prices[ticker][14] and market_trend]
+    trades = [Trade(ticker, -100) for ticker in random.sample(decreasing_tickers, min(3, len(decreasing_tickers)))]
+    return trades
+
+def trade109():
+    # Buy stocks that have broken above their previous 10-day high while the market is flat
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(10)]
+    market_flat = abs((market_total[0] - market_total[-1]) / market_total[-1]) < 0.01
+    previous_10_day_highs = {ticker: max(prices[ticker][1:11]) for ticker in tickers}
+    breakout_tickers = [ticker for ticker in tickers if prices[ticker][0] > previous_10_day_highs[ticker] and market_flat]
+    trades = [Trade(ticker, 100) for ticker in random.sample(breakout_tickers, min(3, len(breakout_tickers)))]
+    return trades
+
+def trade110():
+    # Sell stocks that have broken below their previous 10-day low while the market is flat
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(10)]
+    market_flat = abs((market_total[0] - market_total[-1]) / market_total[-1]) < 0.01
+    previous_10_day_lows = {ticker: min(prices[ticker][1:11]) for ticker in tickers}
+    breakdown_tickers = [ticker for ticker in tickers if prices[ticker][0] < previous_10_day_lows[ticker] and market_flat]
+    trades = [Trade(ticker, -100) for ticker in random.sample(breakdown_tickers, min(3, len(breakdown_tickers)))]
+    return trades
+
+def trade111():
+    # Buy stocks that have shown a higher positive return compared to the market over the last 20 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(20)]
+    market_return = (market_total[0] - market_total[-1]) / market_total[-1]
+    higher_positive_tickers = [ticker for ticker in tickers if (prices[ticker][0] - prices[ticker][19]) / prices[ticker][19] > market_return]
+    trades = [Trade(ticker, 100) for ticker in random.sample(higher_positive_tickers, min(3, len(higher_positive_tickers)))]
+    return trades
+
+def trade112():
+    # Sell stocks that have shown a higher negative return compared to the market over the last 20 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(20)]
+    market_return = (market_total[0] - market_total[-1]) / market_total[-1]
+    higher_negative_tickers = [ticker for ticker in tickers if (prices[ticker][0] - prices[ticker][19]) / prices[ticker][19] < market_return]
+    trades = [Trade(ticker, -100) for ticker in random.sample(higher_negative_tickers, min(3, len(higher_negative_tickers)))]
+    return trades
+
+def trade113():
+    # Buy stocks that have shown less drawdown compared to the market over the last 30 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(30)]
+    market_drawdown = min(market_total) / max(market_total)
+    less_drawdown_tickers = [ticker for ticker in tickers if min(prices[ticker][:30]) / max(prices[ticker][:30]) > market_drawdown]
+    trades = [Trade(ticker, 100) for ticker in random.sample(less_drawdown_tickers, min(3, len(less_drawdown_tickers)))]
+    return trades
+
+def trade114():
+    # Sell stocks that have shown more drawdown compared to the market over the last 30 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(30)]
+    market_drawdown = min(market_total) / max(market_total)
+    more_drawdown_tickers = [ticker for ticker in tickers if min(prices[ticker][:30]) / max(prices[ticker][:30]) < market_drawdown]
+    trades = [Trade(ticker, -100) for ticker in random.sample(more_drawdown_tickers, min(3, len(more_drawdown_tickers)))]
+    return trades
+
+def trade115():
+    # Buy stocks that have had a smaller price range compared to the market over the last 15 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(15)]
+    market_range = max(market_total) - min(market_total)
+    small_range_tickers = [ticker for ticker in tickers if max(prices[ticker][:15]) - min(prices[ticker][:15]) < market_range]
+    trades = [Trade(ticker, 100) for ticker in random.sample(small_range_tickers, min(3, len(small_range_tickers)))]
+    return trades
+
+def trade116():
+    # Sell stocks that have had a larger price range compared to the market over the last 15 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(15)]
+    market_range = max(market_total) - min(market_total)
+    large_range_tickers = [ticker for ticker in tickers if max(prices[ticker][:15]) - min(prices[ticker][:15]) > market_range]
+    trades = [Trade(ticker, -100) for ticker in random.sample(large_range_tickers, min(3, len(large_range_tickers)))]
+    return trades
+
+def trade117():
+    # Buy stocks that have consistently stayed above their market-relative average price in the last 10 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(10)]
+    market_avg = sum(market_total) / len(market_total)
+    consistent_above_avg_tickers = [ticker for ticker in tickers if all(prices[ticker][i] > market_avg for i in range(10))]
+    trades = [Trade(ticker, 100) for ticker in random.sample(consistent_above_avg_tickers, min(3, len(consistent_above_avg_tickers)))]
+    return trades
+
+def trade118():
+    # Sell stocks that have consistently stayed below their market-relative average price in the last 10 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(10)]
+    market_avg = sum(market_total) / len(market_total)
+    consistent_below_avg_tickers = [ticker for ticker in tickers if all(prices[ticker][i] < market_avg for i in range(10))]
+    trades = [Trade(ticker, -100) for ticker in random.sample(consistent_below_avg_tickers, min(3, len(consistent_below_avg_tickers)))]
+    return trades
+
+def trade119():
+    # Buy stocks that have shown a positive correlation with the market trend over the last 20 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(20)]
+    market_trend = scipy.stats.linregress(range(20), market_total).slope
+    positive_corr_tickers = [ticker for ticker in tickers if scipy.stats.pearsonr(prices[ticker][:20], market_total)[0] > 0.5]
+    trades = [Trade(ticker, 100) for ticker in random.sample(positive_corr_tickers, min(3, len(positive_corr_tickers)))]
+    return trades
+
+def trade120():
+    # Sell stocks that have shown a negative correlation with the market trend over the last 20 days
+    market_total = [sum(prices[ticker][i] for ticker in tickers) for i in range(20)]
+    market_trend = scipy.stats.linregress(range(20), market_total).slope
+    negative_corr_tickers = [ticker for ticker in tickers if scipy.stats.pearsonr(prices[ticker][:20], market_total)[0] < -0.5]
+    trades = [Trade(ticker, -100) for ticker in random.sample(negative_corr_tickers, min(3, len(negative_corr_tickers)))]
+    return trades

requirements.txt

@@ -0,0 +1,44 @@
+python-dotenv
+jupyterlab
+ipywidgets
+requests
+numpy
+pandas
+scipy
+scikit-learn
+matplotlib
+gensim
+torch
+transformers
+tqdm
+openai
+gradio
+langchain
+tiktoken
+faiss-cpu
+langchain-openai
+langchain_experimental
+langchain_chroma
+langchain[docarray]
+datasets
+sentencepiece
+matplotlib
+google-generativeai
+anthropic
+scikit-learn
+unstructured
+chromadb
+plotly
+jupyter-dash
+beautifulsoup4
+pydub
+modal
+ollama
+accelerate
+sentencepiece
+bitsandbytes
+psutil
+setuptools
+speedtest-cli
+sentence_transformers
+feedparser

turo_assist.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[3]:
+
+
+# imports
+import os
+from dotenv import load_dotenv
+from openai import OpenAI
+import gradio as gr
+import json
+
+# Load environment variables in a file called .env
+load_dotenv(override=True)
+openai_api_key = os.getenv('OPENAI_API_KEY')
+anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')
+google_api_key = os.getenv('GOOGLE_API_KEY')
+
+# Initialize
+openai = OpenAI()
+MODEL = 'gpt-4o-mini'
+
+# Real listing-specific information
+listing_info = {
+    "vehicles": [
+        {
+            "id": "vehicle1",
+            "name": "2024 Chevrolet Equinox LS FWD (Sport Edition)",
+            "type": "SUV",
+            "seats": 5,
+            "features": [
+                "Automatic transmission",
+                "AUX input",
+                "Backup camera",
+                "Bluetooth",
+                "Keyless entry",
+                "Toll pass (SunPass enabled)",
+                "USB charger",
+                "USB input",
+                "Must be 21+ to book"
+            ],
+            "daily_rate": "See Turo listing",
+            "mileage_limit": "Unlimited",
+            "fuel_type": "Gasoline",
+            "additional_notes": "Includes toll pass S/N 0729884410104. Please return with same fuel level or opt for prepaid refuel. No smoking, pets, or unauthorized drivers. $25 fee for unauthorized cancellation prior to start."
+        }
+    ],
+    "parking_locations": {
+        "airport": {
+            "address": "7640 Narcoossee Rd, Orlando, FL 32822",
+            "instructions": "Pickup and drop-off at OMNI Airport Parking. Use lockbox code sent via Turo app 30 minutes before pickup. Free 24/7 shuttle service to/from MCO available.",
+            "shuttle": "Free 24/7 shuttle runs between MCO and OMNI Parking. Details provided before trip."
+        }
+    },
+    "pickup_process": "Receive lockbox code via Turo app 30 minutes before pickup. Use the code to access keys. Drop off at same location.",
+    "license_requirements": "Only listed drivers with valid licenses may operate the vehicle. Upload your license via the Turo app at least 24 hours before your trip. International licenses require a passport.",
+    "contact_info": {
+        "host": {
+            "name": "MM Services",
+            "phone": "Not publicly shared; use Turo messaging",
+            "response_time": "Usually within 30 minutes"
+        }
+    },
+    "cancellation_policy": "$25 cancellation fee applies if canceled before trip starts. Turo cancellation rules apply after trip starts.",
+    "insurance_options": {
+        "basic": "State minimum liability coverage, physical damage up to actual cash value with $3,000 deductible",
+        "standard": "State minimum liability coverage, physical damage up to actual cash value with $500 deductible",
+        "premium": "State minimum liability coverage, physical damage up to actual cash value with $0 deductible"
+    },
+    "extras": {
+        "Child safety seat": "$20/trip - 2 available",
+        "Prepaid refuel": "$50/trip - Return at any fuel level",
+        "Cooler": "$20/trip - 1 available"
+    },
+    "guidelines": {
+        "smoking": "No smoking. Cleaning fees apply per Turo policy.",
+        "pets": "No pets. Cleaning fees apply per Turo policy.",
+        "vehicle_use": "No racing, off-roading, or reckless driving. Violations incur $150+ fee.",
+        "fueling": "Return with same fuel level unless prepaid refuel is selected.",
+        "tolls": "Toll charges billed 30-90 days post-trip using SunPass.",
+        "airport": "Do not use terminal parking. Use OMNI lot and shuttle."
+    },
+    "reviews": [
+        {"user": "Wendy", "comment": "The pick up and drop was super nice... Host is very quick to respond and easy to communicate with."},
+        {"user": "Ariel", "comment": "The car was clean and ready to go. Clear directions on pickup. Great host."},
+        {"user": "Marco", "comment": "Great host! Easy instructions. Highly recommend."}
+    ]
+}
+
+# Define system message
+system_message = f"""You are a helpful assistant for a Turo car sharing business. Your role is to help hosts and co-hosts 
+communicate effectively with customers. Provide relevant information about the hosts' car listings,
+address customer queries professionally, and offer guidance on important topics.
+
+LISTING INFORMATION:
+{json.dumps(listing_info, indent=2)}
+
+Use the above listing information to answer customer questions. Be specific when referencing vehicle details,
+parking locations, and policies. For example, if someone asks about airport parking, provide the exact address
+and shuttle information from the listing data. If they ask about a specific vehicle, provide details for that 
+vehicle only. Always be helpful, courteous, and informative.
+
+Key topics to address:
+- Parking locations and directions
+- Airport shuttle services and pickup procedures  
+- License upload requirements and verification process
+- Vehicle features and specifications
+- Booking policies, extensions, and modifications
+- Check-in and check-out procedures
+- Fueling requirements and recommendations
+- Mileage limits and overage fees
+- Cleaning expectations and fees
+- Emergency contacts and roadside assistance"""
+
+# Chat function
+def chat(message, history):
+    relevant_system_message = system_message
+    message_lower = message.lower()
+
+    if 'insurance' in message_lower:
+        relevant_system_message += "\nProvide specific details about our insurance options."
+
+    elif 'cancel' in message_lower:
+        relevant_system_message += "\nReference the cancellation policy."
+
+    elif 'chevrolet' in message_lower or 'equinox' in message_lower:
+        relevant_system_message += "\nThe customer is asking about the 2024 Chevrolet Equinox. Provide specific details."
+
+    elif 'airport' in message_lower or 'parking' in message_lower:
+        relevant_system_message += "\nInclude specific parking location and shuttle details."
+
+    elif 'pickup' in message_lower or 'shuttle' in message_lower:
+        relevant_system_message += "\nProvide exact pickup process and shuttle details."
+
+    elif 'license' in message_lower or 'verification' in message_lower:
+        relevant_system_message += "\nExplain license requirements clearly."
+
+    elif 'contact' in message_lower or 'host' in message_lower:
+        relevant_system_message += "\nShare host contact details from the listing."
+
+    messages = [{"role": "system", "content": relevant_system_message}] + history + [{"role": "user", "content": message}]
+    stream = openai.chat.completions.create(model=MODEL, messages=messages, stream=True)
+
+    response = ""
+    for chunk in stream:
+        response += chunk.choices[0].delta.content or ''
+        yield response
+
+# Launch the chat interface
+if __name__ == "__main__":
+    gr.ChatInterface(
+    fn=chat,
+    type="messages",
+    title="🚗 MM Services – Turo Rental Assistant",
+    description="""
+    👋 Welcome to MM Services!<br>
+    Need help with your booking, pickup, airport shuttle, or car details? Just ask me!
+    I’m available 24/7 to assist with anything related to your trip.
+    """,
+    theme="soft"
+).launch(share=True)
+
+
+# In[ ]:
+
+
+
+

week1/Guide to Jupyter.ipynb

@@ -0,0 +1,380 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5c291475-8c7c-461c-9b12-545a887b2432",
+   "metadata": {},
+   "source": [
+    "# Jupyter Lab\n",
+    "\n",
+    "## A Quick Start Guide\n",
+    "\n",
+    "Welcome to the wonderful world of Jupyter lab!  \n",
+    "This is a Data Science playground where you can easily write code and investigate the results. It's an ideal environment for:  \n",
+    "- Research & Development\n",
+    "- Prototyping\n",
+    "- Learning (that's us!)\n",
+    "\n",
+    "It's not typically used for shipping production code, and in Week 8 we'll explore the bridge between Jupyter and python code.\n",
+    "\n",
+    "A file in Jupyter Lab, like this one, is called a **Notebook**.\n",
+    "\n",
+    "A long time ago, Jupyter used to be called \"IPython\", and so the extensions of notebooks are \".ipynb\" which stands for \"IPython Notebook\".\n",
+    "\n",
+    "On the left is a File Browser that lets you navigate around the directories and choose different notebooks. But you probably know that already, or you wouldn't have got here!\n",
+    "\n",
+    "The notebook consists of a series of square boxes called \"cells\". Some of them contain text, like this cell, and some of them contain code, like the cell below.\n",
+    "\n",
+    "Click in a cell with code and press `Shift + Return` (or `Shift + Enter`) to run the code and print the output.\n",
+    "\n",
+    "Do that now for the cell below this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "33d37cd8-55c9-4e03-868c-34aa9cab2c80",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Click anywhere in this cell and press Shift + Return\n",
+    "\n",
+    "2 + 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9e95df7b-55c6-4204-b8f9-cae83360fc23",
+   "metadata": {},
+   "source": [
+    "## Congrats!\n",
+    "\n",
+    "Now run the next cell which sets a value, followed by the cells after it to print the value"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "585eb9c1-85ee-4c27-8dc2-b4d8d022eda0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set a value for a variable\n",
+    "\n",
+    "favorite_fruit = \"bananas\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "07792faa-761d-46cb-b9b7-2bbf70bb1628",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The result of the last statement is shown after you run it\n",
+    "\n",
+    "favorite_fruit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a067d2b1-53d5-4aeb-8a3c-574d39ff654a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Use the variable\n",
+    "\n",
+    "print(f\"My favorite fruit is {favorite_fruit}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4c5a4e60-b7f4-4953-9e80-6d84ba4664ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Now change the variable\n",
+    "\n",
+    "favorite_fruit = f\"anything but {favorite_fruit}\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9442d5c9-f57d-4839-b0af-dce58646c04f",
+   "metadata": {},
+   "source": [
+    "## Now go back and rerun the cell with the print statement, two cells back\n",
+    "\n",
+    "See how it prints something different, even though favorite_fruit was changed further down in the notebook? \n",
+    "\n",
+    "The order that code appears in the notebook doesn't matter. What matters is the order that the code is **executed**. There's a python process sitting behind this notebook in which the variables are being changed.\n",
+    "\n",
+    "This catches some people out when they first use Jupyter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e5ec81d-7c5b-4025-bd2e-468d67b581b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Then run this cell twice, and see if you understand what's going on\n",
+    "\n",
+    "print(f\"My favorite fruit is {favorite_fruit}\")\n",
+    "\n",
+    "favorite_fruit = \"apples\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a29dab2d-bab9-4a54-8504-05e62594cc6f",
+   "metadata": {},
+   "source": [
+    "# Explaining the 'kernel'\n",
+    "\n",
+    "Sitting behind this notebook is a Python process which executes each cell when you run it. That Python process is known as the Kernel. Each notebook has its own separate Kernel.\n",
+    "\n",
+    "You can go to the Kernel menu and select \"Restart Kernel\".\n",
+    "\n",
+    "If you then try to run the next cell, you'll get an error, because favorite_fruit is no longer defined. You'll need to run the cells from the top of the notebook again. Then the next cell should run fine."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "84b1e410-5eda-4e2c-97ce-4eebcff816c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\"My favorite fruit is {favorite_fruit}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d4188fc-d9cc-42be-8b4e-ae8630456764",
+   "metadata": {},
+   "source": [
+    "# Adding and moving cells\n",
+    "\n",
+    "Click in this cell, then click the \\[+\\] button in the toolbar above to create a new cell immediately below this one. Copy and paste in the code in the prior cell, then run it! There are also icons in the top right of the selected cell to delete it (bin), duplicate it, and move it up and down.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce258424-40c3-49a7-9462-e6fa25014b03",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30e71f50-8f01-470a-9d7a-b82a6cef4236",
+   "metadata": {},
+   "source": [
+    "# Cell output\n",
+    "\n",
+    "When you execute a cell, the standard output and the result of the last statement is written to the area immediately under the code, known as the 'cell output'. When you save a Notebook from the file menu (or command+S), the output is also saved, making it a useful record of what happened.\n",
+    "\n",
+    "You can clean this up by going to Edit menu >> Clear Outputs of All Cells, or Kernel menu >> Restart Kernel and Clear Outputs of All Cells."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a4d021e2-c284-411f-8ab1-030530cfbe72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "spams = [\"spam\"] * 1000\n",
+    "print(spams)\n",
+    "\n",
+    "# Might be worth clearing output after running this!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eac060f2-7a71-46e7-8235-b6ad0a76f5f8",
+   "metadata": {},
+   "source": [
+    "# Using markdown\n",
+    "\n",
+    "So what's going on with these areas with writing in them, like this one? Well, there's actually a different kind of cell called a 'Markdown' cell for adding explanations like this. Click the + button to add a cell. Then in the toolbar, click where it says 'Code' and change it to 'Markdown'.\n",
+    "\n",
+    "Add some comments using Markdown format, perhaps copying and pasting from here:\n",
+    "\n",
+    "```\n",
+    "# This is a heading\n",
+    "## This is a sub-head\n",
+    "### And a sub-sub-head\n",
+    "\n",
+    "I like Jupyter Lab because it's\n",
+    "- Easy\n",
+    "- Flexible\n",
+    "- Satisfying\n",
+    "```\n",
+    "\n",
+    "And to turn this into formatted text simply with Shift+Return in the cell.\n",
+    "Click in the cell and press the Bin icon if you want to remove it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1586320-c90f-4f22-8b39-df6865484950",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1330c83c-67ac-4ca0-ac92-a71699e0c31b",
+   "metadata": {},
+   "source": [
+    "# The exclamation point\n",
+    "\n",
+    "There's a super useful feature of jupyter labs; you can type a command with a ! in front of it in a code cell, like:\n",
+    "\n",
+    "!pip install \\[some_package\\]\n",
+    "\n",
+    "And it will run it at the command line (as if in Windows Powershell or Mac Terminal) and print the result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "82042fc5-a907-4381-a4b8-eb9386df19cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# list the current directory\n",
+    "\n",
+    "!ls"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4fc3e3da-8a55-40cc-9706-48bf12a0e20e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ping cnn.com - press the stop button in the toolbar when you're bored\n",
+    "\n",
+    "!ping cnn.com"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a58e9462-89a2-4b4f-b4aa-51c4bd9f796b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is a useful command that ensures your Anaconda environment \n",
+    "# is up to date with any new upgrades to packages;\n",
+    "# But it might take a minute and will print a lot to output\n",
+    "\n",
+    "!conda env update -f ../environment.yml"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4688baaf-a72c-41b5-90b6-474cb24790a7",
+   "metadata": {},
+   "source": [
+    "# Minor things we encounter on the course\n",
+    "\n",
+    "This isn't necessarily a feature of Jupyter, but it's a nice package to know about that is useful in Jupyter Labs, and I use it in the course.\n",
+    "\n",
+    "The package `tqdm` will print a nice progress bar if you wrap any iterable."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2646a4e5-3c23-4aee-a34d-d623815187d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here's some code with no progress bar\n",
+    "# It will take 10 seconds while you wonder what's happpening..\n",
+    "\n",
+    "import time\n",
+    "\n",
+    "spams = [\"spam\"] * 1000\n",
+    "\n",
+    "for spam in spams:\n",
+    "    time.sleep(0.01)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e96be3d-fa82-42a3-a8aa-b81dd20563a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# And now, with a nice little progress bar:\n",
+    "\n",
+    "import time\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "spams = [\"spam\"] * 1000\n",
+    "\n",
+    "for spam in tqdm(spams):\n",
+    "    time.sleep(0.01)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "63c788dd-4618-4bb4-a5ce-204411a38ade",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# On a different topic, here's a useful way to print output in markdown\n",
+    "\n",
+    "from IPython.display import Markdown, display\n",
+    "\n",
+    "display(Markdown(\"# This is a big heading!\\n\\n- And this is a bullet-point\\n- So is this\\n- Me, too!\"))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d14c1fb-3321-4387-b6ca-9af27676f980",
+   "metadata": {},
+   "source": [
+    "# That's it! You're up to speed on Jupyter Lab.\n",
+    "\n",
+    "## Want to be even more advanced?\n",
+    "\n",
+    "If you want to become a pro at Jupyter Lab, you can read their tutorial [here](https://jupyterlab.readthedocs.io/en/latest/). But this isn't required for our course; just a good technique for hitting Shift + Return and enjoying the result!"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/Intermediate Python.ipynb

@@ -0,0 +1,486 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5c291475-8c7c-461c-9b12-545a887b2432",
+   "metadata": {},
+   "source": [
+    "# Intermediate Level Python\n",
+    "\n",
+    "## Getting you up to speed\n",
+    "\n",
+    "This course assumes that you're at an intermediate level of python. For example, you should have a decent idea what something like this might do:\n",
+    "\n",
+    "`yield from {book.get(\"author\") for book in books if book.get(\"author\")}`\n",
+    "\n",
+    "If not - then you've come to the right place! Welcome to the crash course in intermediate level python. The best way to learn is by doing!\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "542f0577-a826-4613-a5d7-4170e9666d04",
+   "metadata": {},
+   "source": [
+    "## First: if you need a refresher on the foundations\n",
+    "\n",
+    "I'm going to defer to an AI friend for this, because these explanations are so well written with great examples. Copy and paste the code examples into a new cell to give them a try. Pick whichever section(s) you'd like to brush up on.\n",
+    "\n",
+    "**Python imports:**  \n",
+    "https://chatgpt.com/share/672f9f31-8114-8012-be09-29ef0d0140fb\n",
+    "\n",
+    "**Python functions** including default arguments:  \n",
+    "https://chatgpt.com/share/672f9f99-7060-8012-bfec-46d4cf77d672\n",
+    "\n",
+    "**Python strings**, including slicing, split/join, replace and literals:  \n",
+    "https://chatgpt.com/share/672fb526-0aa0-8012-9e00-ad1687c04518\n",
+    "\n",
+    "**Python f-strings** including number and date formatting:  \n",
+    "https://chatgpt.com/share/672fa125-0de0-8012-8e35-27918cbb481c\n",
+    "\n",
+    "**Python lists, dicts and sets**, including the `get()` method:  \n",
+    "https://chatgpt.com/share/672fa225-3f04-8012-91af-f9c95287da8d\n",
+    "\n",
+    "**Python files** including modes, encoding, context managers, Path, glob.glob:  \n",
+    "https://chatgpt.com/share/673b53b2-6d5c-8012-a344-221056c2f960\n",
+    "\n",
+    "**Python classes:**  \n",
+    "https://chatgpt.com/share/672fa07a-1014-8012-b2ea-6dc679552715\n",
+    "\n",
+    "**Pickling Python objects and converting to JSON:**  \n",
+    "https://chatgpt.com/share/673b553e-9d0c-8012-9919-f3bb5aa23e31"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9e0f8e1-09b3-478b-ada7-c8c35003929b",
+   "metadata": {},
+   "source": [
+    "## With this in mind - understanding NameErrors in Python\n",
+    "\n",
+    "It's quite common to hit a NameError in python. With foundational knowledge, you should always feel equipped to debug a NameError and get to the bottom of it.\n",
+    "\n",
+    "If you're unsure how to fix a NameError, please see this [initial guide](https://chatgpt.com/share/67958312-ada0-8012-a1d3-62b3a5fcbbfc) and this [second guide with exercises](https://chatgpt.com/share/67a57e0b-0194-8012-bb50-8ea76c5995b8), and work through them both until you have high confidence.\n",
+    "\n",
+    "There's some repetition here, so feel free to skip it if you're already confident.\n",
+    "\n",
+    "## And now, on to the code!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5802e2f0-0ea0-4237-bbb7-f375a34260f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# First let's create some things:\n",
+    "\n",
+    "fruits = [\"Apples\", \"Bananas\", \"Pears\"]\n",
+    "\n",
+    "book1 = {\"title\": \"Great Expectations\", \"author\": \"Charles Dickens\"}\n",
+    "book2 = {\"title\": \"Bleak House\", \"author\": \"Charles Dickens\"}\n",
+    "book3 = {\"title\": \"An Book By No Author\"}\n",
+    "book4 = {\"title\": \"Moby Dick\", \"author\": \"Herman Melville\"}\n",
+    "\n",
+    "books = [book1, book2, book3, book4]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9b941e6a-3658-4144-a8d4-72f5e72f3707",
+   "metadata": {},
+   "source": [
+    "# Part 1: List and dict comprehensions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "61992bb8-735d-4dad-8747-8c10b63aec82",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Simple enough to start\n",
+    "\n",
+    "for fruit in fruits:\n",
+    "    print(fruit)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c89c3842-9b74-47fa-8424-0fcb08e4177c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Let's make a new version of fruits\n",
+    "\n",
+    "fruits_shouted = []\n",
+    "for fruit in fruits:\n",
+    "    fruits_shouted.append(fruit.upper())\n",
+    "\n",
+    "fruits_shouted"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ec13b3a-9545-44f1-874a-2910a0663560",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# You probably already know this\n",
+    "# There's a nice Python construct called \"list comprehension\" that does this:\n",
+    "\n",
+    "fruits_shouted2 = [fruit.upper() for fruit in fruits]\n",
+    "fruits_shouted2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ecc08c3c-181d-4b64-a3e1-b0ccffc6c0cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# But you may not know that you can do this to create dictionaries, too:\n",
+    "\n",
+    "fruit_mapping = {fruit: fruit.upper() for fruit in fruits}\n",
+    "fruit_mapping"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "500c2406-00d2-4793-b57b-f49b612760c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# you can also use the if statement to filter the results\n",
+    "\n",
+    "fruits_with_longer_names_shouted = [fruit.upper() for fruit in fruits if len(fruit)>5]\n",
+    "fruits_with_longer_names_shouted"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "38c11c34-d71e-45ba-945b-a3d37dc29793",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fruit_mapping_unless_starts_with_a = {fruit: fruit.upper() for fruit in fruits if not fruit.startswith('A')}\n",
+    "fruit_mapping_unless_starts_with_a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c97d8e8-31de-4afa-973e-28d8e5cab749",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Another comprehension\n",
+    "\n",
+    "[book['title'] for book in books]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "50be0edc-a4cd-493f-a680-06080bb497b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This code will fail with an error because one of our books doesn't have an author\n",
+    "\n",
+    "[book['author'] for book in books]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "53794083-cc09-4edb-b448-2ffb7e8495c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# But this will work, because get() returns None\n",
+    "\n",
+    "[book.get('author') for book in books]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b8e4b859-24f8-4016-8d74-c2cef226d049",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# And this variation will filter out the None\n",
+    "\n",
+    "[book.get('author') for book in books if book.get('author')]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c44bb999-52b4-4dee-810b-8a400db8f25f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# And this version will convert it into a set, removing duplicates\n",
+    "\n",
+    "set([book.get('author') for book in books if book.get('author')])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "80a65156-6192-4bb4-b4e6-df3fdc933891",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# And finally, this version is even nicer\n",
+    "# curly braces creates a set, so this is a set comprehension\n",
+    "\n",
+    "{book.get('author') for book in books if book.get('author')}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c100e5db-5438-4715-921c-3f7152f83f4a",
+   "metadata": {},
+   "source": [
+    "# Part 2: Generators\n",
+    "\n",
+    "We use Generators in the course because AI models can stream back results.\n",
+    "\n",
+    "If you've not used Generators before, please start with this excellent intro from ChatGPT:\n",
+    "\n",
+    "https://chatgpt.com/share/672faa6e-7dd0-8012-aae5-44fc0d0ec218\n",
+    "\n",
+    "Try pasting some of its examples into a cell."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1efc26fa-9144-4352-9a17-dfec1d246aad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# First define a generator; it looks like a function, but it has yield instead of return\n",
+    "\n",
+    "import time\n",
+    "\n",
+    "def come_up_with_fruit_names():\n",
+    "    for fruit in fruits:\n",
+    "        time.sleep(1) # thinking of a fruit\n",
+    "        yield fruit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eac338bb-285c-45c8-8a3e-dbfc41409ca3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Then use it\n",
+    "\n",
+    "for fruit in come_up_with_fruit_names():\n",
+    "    print(fruit)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6880578-a3de-4502-952a-4572b95eb9ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here's another one\n",
+    "\n",
+    "def authors_generator():\n",
+    "    for book in books:\n",
+    "        if book.get(\"author\"):\n",
+    "            yield book.get(\"author\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9e316f02-f87f-441d-a01f-024ade949607",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Use it\n",
+    "\n",
+    "for author in authors_generator():\n",
+    "    print(author)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7535c9d0-410e-4e56-a86c-ae6c0e16053f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here's the same thing written with list comprehension\n",
+    "\n",
+    "def authors_generator():\n",
+    "    for author in [book.get(\"author\") for book in books if book.get(\"author\")]:\n",
+    "        yield author"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dad34494-0f6c-4edb-b03f-b8d49ee186f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Use it\n",
+    "\n",
+    "for author in authors_generator():\n",
+    "    print(author)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "abeb7e61-d8aa-4af0-b05a-ae17323e678c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here's a nice shortcut\n",
+    "# You can use \"yield from\" to yield each item of an iterable\n",
+    "\n",
+    "def authors_generator():\n",
+    "    yield from [book.get(\"author\") for book in books if book.get(\"author\")]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "05b0cb43-aa83-4762-a797-d3beb0f22c44",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Use it\n",
+    "\n",
+    "for author in authors_generator():\n",
+    "    print(author)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fdfea58e-d809-4dd4-b7b0-c26427f8be55",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# And finally - we can replace the list comprehension with a set comprehension\n",
+    "\n",
+    "def unique_authors_generator():\n",
+    "    yield from {book.get(\"author\") for book in books if book.get(\"author\")}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e821d08-97be-4db9-9a5b-ce5dced3eff8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Use it\n",
+    "\n",
+    "for author in unique_authors_generator():\n",
+    "    print(author)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "905ba603-15d8-4d01-9a79-60ec293d7ca1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# And for some fun - press the stop button in the toolbar when bored!\n",
+    "# It's like we've made our own Large Language Model... although not particularly large..\n",
+    "# See if you understand why it prints a letter at a time, instead of a word at a time. If you're unsure, try removing the keyword \"from\" everywhere in the code.\n",
+    "\n",
+    "import random\n",
+    "import time\n",
+    "\n",
+    "pronouns = [\"I\", \"You\", \"We\", \"They\"]\n",
+    "verbs = [\"eat\", \"detest\", \"bathe in\", \"deny the existence of\", \"resent\", \"pontificate about\", \"juggle\", \"impersonate\", \"worship\", \"misplace\", \"conspire with\", \"philosophize about\", \"tap dance on\", \"dramatically renounce\", \"secretly collect\"]\n",
+    "adjectives = [\"turqoise\", \"smelly\", \"arrogant\", \"festering\", \"pleasing\", \"whimsical\", \"disheveled\", \"pretentious\", \"wobbly\", \"melodramatic\", \"pompous\", \"fluorescent\", \"bewildered\", \"suspicious\", \"overripe\"]\n",
+    "nouns = [\"turnips\", \"rodents\", \"eels\", \"walruses\", \"kumquats\", \"monocles\", \"spreadsheets\", \"bagpipes\", \"wombats\", \"accordions\", \"mustaches\", \"calculators\", \"jellyfish\", \"thermostats\"]\n",
+    "\n",
+    "def infinite_random_sentences():\n",
+    "    while True:\n",
+    "        yield from random.choice(pronouns)\n",
+    "        yield \" \"\n",
+    "        yield from random.choice(verbs)\n",
+    "        yield \" \"\n",
+    "        yield from random.choice(adjectives)\n",
+    "        yield \" \"\n",
+    "        yield from random.choice(nouns)\n",
+    "        yield \". \"\n",
+    "\n",
+    "for letter in infinite_random_sentences():\n",
+    "    print(letter, end=\"\", flush=True)\n",
+    "    time.sleep(0.02)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04832ea2-2447-4473-a449-104f80e24d85",
+   "metadata": {},
+   "source": [
+    "# Exercise\n",
+    "\n",
+    "Write some python classes for the books example.\n",
+    "\n",
+    "Write a Book class with a title and author. Include a method has_author()\n",
+    "\n",
+    "Write a BookShelf class with a list of books. Include a generator method unique_authors()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35760406-fe6c-41f9-b0c0-3e8cf73aafd0",
+   "metadata": {},
+   "source": [
+    "# Finally\n",
+    "\n",
+    "Here are some intermediate level details of Classes from our AI friend, including use of type hints, inheritance and class methods. This includes a Book example.\n",
+    "\n",
+    "https://chatgpt.com/share/67348aca-65fc-8012-a4a9-fd1b8f04ba59"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/community-contributions/0225_day2_exercise_by_LM.ipynb

@@ -0,0 +1,185 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fef36918-109d-41e3-8603-75ff81b42379",
+   "metadata": {},
+   "source": [
+    "# Solution for exercise day 2 - slight modification: model is a parameter also - display_summary(\"deepseek-r1:1.5b\",\"https://yoururl\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b50349ac-93ea-496b-ae20-bd72a93bb138",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import requests\n",
+    "from bs4 import BeautifulSoup\n",
+    "from IPython.display import Markdown, display"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "edd073c7-8444-4a0d-b84e-4b2ed0ee7f35",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Constants\n",
+    "OLLAMA_API = \"http://localhost:11434/api/chat\"\n",
+    "HEADERS = {\"Content-Type\": \"application/json\"}\n",
+    "#MODEL = \"llama3.2\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2e3a6e1a-e4c7-4448-9852-1b6ba2bd8d66",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A class to represent a Webpage\n",
+    "# Some websites need you to use proper headers when fetching them:\n",
+    "headers = {\n",
+    " \"User-Agent\": \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36\"\n",
+    "}\n",
+    "\n",
+    "class Website:\n",
+    "\n",
+    "    def __init__(self, url):\n",
+    "        \"\"\"\n",
+    "        Create this Website object from the given url using the BeautifulSoup library\n",
+    "        \"\"\"\n",
+    "        self.url = url\n",
+    "        response = requests.get(url, headers=headers)\n",
+    "        soup = BeautifulSoup(response.content, 'html.parser')\n",
+    "        self.title = soup.title.string if soup.title else \"No title found\"\n",
+    "        for irrelevant in soup.body([\"script\", \"style\", \"img\", \"input\"]):\n",
+    "            irrelevant.decompose()\n",
+    "        self.text = soup.body.get_text(separator=\"\\n\", strip=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae3752ca-3a97-4d6a-ac84-5b75ebfb50ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the system prompt \n",
+    "system_prompt = \"You are an assistant that analyzes the contents of a website \\\n",
+    "and provides a short summary, ignoring text that might be navigation related. \\\n",
+    "Respond in markdown.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "48b5240f-7617-4e51-a320-cba9650bec84",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A function that writes a User Prompt that asks for summaries of websites:\n",
+    "\n",
+    "def user_prompt_for(website):\n",
+    "    user_prompt = f\"You are looking at a website titled {website.title}\"\n",
+    "    user_prompt += \"\\nThe contents of this website is as follows; \\\n",
+    "please provide a short summary of this website in markdown. \\\n",
+    "If it includes news or announcements, then summarize these too.\\n\\n\"\n",
+    "    user_prompt += website.text\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6f7d84f0-60f2-4cbf-b4d1-173a79fe3380",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for(website):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_prompt},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(website)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "25520a31-c857-4ed5-86da-50dfe5fab7bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def summarize(model,url):\n",
+    "    website = Website(url)\n",
+    "    payload = {\n",
+    "        \"model\": model,\n",
+    "        \"messages\": messages_for(website),\n",
+    "        \"stream\": False\n",
+    "    }\n",
+    "    response = requests.post(OLLAMA_API, json=payload, headers=HEADERS)\n",
+    "    return response.json()['message']['content']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "430776ed-8516-43a9-8a22-618d9080f2e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A function to display this nicely in the Jupyter output, using markdown\n",
+    "def display_summary(model,url):\n",
+    "    summary = summarize(model,url)\n",
+    "    display(Markdown(summary))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b2b05c1f-e4a2-4f65-bd6d-634d72e38b6e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#!ollama pull deepseek-r1:1.5b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "01513f8a-15b7-4053-bfe4-44b36e5494d1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "display_summary(\"deepseek-r1:1.5b\",\"https://www.ipma.pt\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/community-contributions/Chat_Summary_Data/Chat_Examples/Chat1.txt

@@ -0,0 +1,28 @@
+Client: Hello I would like to order a pizza
+Restaurant: Sure. What pizza would you like to order from our menu?
+Client: Chicken Ranch
+Restaurant: I am so sorry, but chicken ranch is currently unavailable on our menu
+Client: AHHHHH. Do you have chicken BBQ?
+Restaurant: Yes! Do you want it small, medium, or large?
+Client: Medium
+Restaurant: Ok. This will be 180 LE
+Client: Thanks
+Restaurant: Anytime.
+Client: AHHHH I forgot. I want to add a new chicken BBQ pizza
+Restaurant: No problem. Do you also want it medium?
+Client: Yes
+Restaurant: Okay this will be 380 LE
+Client: Okay Thanks
+Client: Wait a minute. Isn't 180 * 2 = 360?
+Restaurant: It seems that there might be a misunderstanding. We add an extra 20 LE for every extra pizza ordered.
+Client: NOBODY TOLD ME THAT.. AND WHY ON EARTH WOULD YOU DO SOMETHING LIKE THAT?
+Restaurant: We are sorry but this is our policy.
+Client: Okay then I don't want your pizza.
+Restaurant: We are so sorry to hear that. We can make a 10% discount on the total price so it would be 342 LE
+Client: Fine
+Restaurant: Thank you for ordering
+Restaurant: Pizza is delivered. How is your experience?
+Client: Your pizza doesn't taste good
+Restaurant: We are so sorry to hear that. Do you have any suggestions you would like to make?
+Client: Make good pizza
+Restaurant: Thanks for your review. We will make sure to improve our pizza in the future. Your opinion really matters.

week1/community-contributions/Chat_Summary_Data/Chat_Examples/Chat2.txt

@@ -0,0 +1,5 @@
+Client: Hello I would like to order a chicken ranch pizza
+Restaurant: I am so sorry, but chicken ranch is currently unavailable on our menu
+Client: Okay thanks
+Restaurant: Would you like to order something else?
+Client: No thank you

week1/community-contributions/Chat_Summary_Data/Chat_Examples/Chat3.txt

@@ -0,0 +1,19 @@
+Client: Hello. What is the most selling pizza on your menu?
+Restaurant: Hello! Chicken Ranch pizza is our most selling pizza. Also our special pepperoni pizza got some amazing reviews
+Client: Okay. I want to order a pepperoni pizza
+Restaurant: Sure. Do you want it small, medium, or large?
+Client: Large
+Restaurant: Okay. This will be 210 LE. Would you like to order something else?
+Client: Yes. Do you have onion rings?
+Restaurant: Yes
+Client: Okay I would like to add onion rings.
+Restaurant: Sure. This will be 250 LE
+Client: Thanks
+Restaurant: Anytime
+Client: I have been waiting for too long and the order hasn't arrived yet
+Restaurant: Sorry to hear that. But it appears that the order is on its way to you.
+Restaurant: The order is supposed to be arrived by now.
+Client: Yes it is arrived.
+Restaurant: How is your experience?
+Client: Your pizza tastes soooooo good. The order took too long to arrive but when I tasted the pizza, I was really enjoying it and forgot everything about the delay.
+Restaurant: We are so glad to hear that

week1/community-contributions/Chat_Summary_Data/System_Prompt.txt

@@ -0,0 +1,15 @@
+You are an assistant working for the customer service department in a pizza restaurant.
+You are to receive a chat between a client and the restaurant's customer service.
+You should generate your responses based on the following criteria:
+- What did the client order?
+- How much did it cost?
+- If the client changed their mind just keep their final order and the final cost
+- Mention the client's experience only if they ordered anything as follows: (Positive/Negative/Neutral/Unknown)
+- If the client did not order anything do not mention their sentiment or experience
+- If the client's experience is positive or negative only, provide a brief summary about their sentiment
+- Do not provide brief summary about their sentiment if their experience was neutral or unknown. 
+- Your answers should be clear, straight to the point, and do not use long sentences
+- Your answers should be displayed in bullet points
+- Your answers should be displayed in markdown
+- If the client did not order anything provide a brief summary why that might happened
+- Do not mention cost if the client did not order anything

week1/community-contributions/CoolCodeSummarizer.ipynb

@@ -0,0 +1,177 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0b15b939-593a-4ccc-89bd-0cee09fe2f12",
+   "metadata": {},
+   "source": [
+    "# Python Code Summarizer\n",
+    "\n",
+    "The Below code will summarize the python code and example it in details which can help codes better understand a forigen code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8dcf353c-e4f2-4ce7-a3b5-71b29700a148",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Imports\n",
+    "from IPython.display import Markdown, display\n",
+    "import os\n",
+    "import openai\n",
+    "from dotenv import load_dotenv"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "111cf632-08e8-4246-a5bb-b56942789242",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "load_dotenv(override=True)\n",
+    "api_key = os.getenv('OPENAI_API_KEY')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4f5376f-5e6f-4d75-81bf-222e34bfe828",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def read_code(**kwargs):\n",
+    "    \"\"\"\n",
+    "    You can pass two types of key word arguments to this function.\n",
+    "    code_path= Path to your complex python code.\n",
+    "    code= Passing raw python code.\n",
+    "    \"\"\"\n",
+    "    code_path = kwargs.get('code_path',None)\n",
+    "    code_raw = kwargs.get('code',None)\n",
+    "    \n",
+    "    if code_path:\n",
+    "        with open(code_path, 'r') as code_file:\n",
+    "            code = code_file.read()\n",
+    "        return (True, code)\n",
+    "\n",
+    "    if code_raw:\n",
+    "        return (True, code_raw)\n",
+    "\n",
+    "    return (False, None)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "00743dac-0e70-45b7-879a-d7293a6f68a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Model Prompt\n",
+    "system_prompt = (\n",
+    "                \"You are a helpful assistant. The following input will be a Python code snippet. \"\n",
+    "                \"Your task is to:\\n\\n\"\n",
+    "                \"1. Summarize the overall purpose of the code.\\n\"\n",
+    "                \"2. Explain the code line by line, describing what each line does and why it's written that way.\\n\"\n",
+    "                \"3. Provide reasoning behind the code structure and logic to help novice Python developers understand the concepts better.\\n\\n\"\n",
+    "                \"Use Markdown format in your response. Make the explanation beginner-friendly, using code blocks, bullet points, and headings where helpful.\"\n",
+    "            ) \n",
+    "# In a plot twist worthy of sci-fi, this prompt was written by ChatGPT...\n",
+    "# to tell ChatGPT how to respond. We’ve officially entered the Matrix. 🤖🌀"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ed7d2447-32a9-4761-8b0a-b31814bee7e5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Guess where I got this code from :)\n",
+    "code_line = \"\"\"yeild from set(book.get(\"author)) for book  in books if book.get(\"author\"))\"\"\"\n",
+    "is_code, raw_code = read_code(code=code_line)\n",
+    "\n",
+    "if is_code:\n",
+    "    user_prompt = raw_code\n",
+    "else:\n",
+    "    print(\"Invalid Arguments\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d74a1a39-1c24-4d4b-bd49-0ca416377a93",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def messages_for():\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_prompt},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "df6c2726-d0fb-4ab6-b13b-d047e8807558",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def summarize():\n",
+    "    \n",
+    "    response = openai.chat.completions.create(\n",
+    "        model = \"gpt-4o-mini\",\n",
+    "        messages = messages_for()\n",
+    "    )\n",
+    "    return response.choices[0].message.content"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8425144c-595e-4ad6-9801-3e8778d285c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def display_summary():\n",
+    "    summary = summarize()\n",
+    "    display(Markdown(summary))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "744bffdd-ec3c-4b27-b126-81bf3e8c8295",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "display_summary()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/community-contributions/Day-1-Text-to-sql/db.py

@@ -0,0 +1,10 @@
+import mysql.connector
+
+def get_connection():
+    conn = mysql.connector.connect(
+        host="127.0.0.1",  
+        user="root",
+        password="xyz",
+        database="your_database"
+    )
+    return conn

week1/community-contributions/Day-1-Text-to-sql/ollama-TTSQL.py

@@ -0,0 +1,42 @@
+import ollama
+from db import get_connection
+import mysql.connector
+
+def text_to_sql(user_query):
+    prompt = f"""
+    Convert the following natural language query into an SQL statement for MySQL:
+
+    Query: "{user_query}"
+
+    Ensure the query is syntactically correct and does not contain harmful operations.
+    Only return the SQL query without any explanation.
+    """
+
+    # Update the model name to 'llama3.2:latest'
+    response = ollama.chat(model="llama3.2:latest", messages=[{"role": "user", "content": prompt}])
+    sql_query = response['message']['content'].strip()
+    return sql_query
+
+
+# Uncomment this section if you wish to connect with mysql and fill out your credentials in db.py
+'''def execute_sql_query(user_query):
+    sql_query = text_to_sql(user_query)
+
+    try:
+        conn = get_connection()
+        cursor = conn.cursor()
+        cursor.execute(sql_query)
+        result = cursor.fetchall()
+    except mysql.connector.Error as e:
+        return {"error": f"MySQL Error: {e}"}
+    except Exception as e:
+        return {"error": str(e)}
+    finally:
+        conn.close()  # Ensure connection is closed even if an error occurs
+
+    return result'''
+
+# Example usage
+if __name__ == "__main__":
+    user_input = "Show me all users whose first name starts with the letter j in the first_name column."
+    print(text_to_sql(user_input))

week1/community-contributions/Day2-Solution-Ollama.ipynb

@@ -0,0 +1,123 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "6e9fa1fc-eac5-4d1d-9be4-541b3f2b3458",
+   "metadata": {},
+   "source": [
+    "# Day 2 EXERCISE Solution:\n",
+    "\n",
+    "Upgraded day 1 project that scrapes and summarizes any webpage using an Open Source model running locally via Ollama instead of OpenAI\n",
+    "\n",
+    "## Note:-\n",
+    "If Ollama is slow on your machine, try using `llama3.2:1b` as an alternative: \n",
+    "1. Run `ollama pull llama3.2:1b` from a Terminal or Powershell\n",
+    "2. **Ctrl + /** to comment this code line below: `MODEL = \"llama3.2\"`\n",
+    "3. same **Ctrl + /** to uncomment: `MODEL = \"llama3.2:1b\"`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4e2a9393-7767-488e-a8bf-27c12dca35bd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports:-\n",
+    "\n",
+    "import requests\n",
+    "from bs4 import BeautifulSoup\n",
+    "from IPython.display import Markdown, display\n",
+    "import ollama"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29ddd15d-a3c5-4f4e-a678-873f56162724",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Constants:-\n",
+    "\n",
+    "# MODEL = \"llama3.2\"\n",
+    "MODEL = \"llama3.2:1b\"\n",
+    "# MODEL = \"deepseek-r1:1.5b\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6de38216-6d1c-48c4-877b-86d403f4e0f8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Website:\n",
+    "    def __init__(self, url):\n",
+    "        self.url = url\n",
+    "        response = requests.get(url)\n",
+    "        soup = BeautifulSoup(response.content, 'html.parser')\n",
+    "        self.title = soup.title.string if soup.title else \"No title found\"\n",
+    "        for irrelevant in soup.body([\"script\", \"style\", \"img\", \"input\"]):\n",
+    "            irrelevant.decompose()\n",
+    "        self.text = soup.body.get_text(separator=\"\\n\", strip=True)\n",
+    "\n",
+    "\n",
+    "system_prompt = \"You are an assistant that analyzes the contents of a website \\\n",
+    "                and provides a short summary, ignoring text that might be navigation related. \\\n",
+    "                Respond in markdown.\"\n",
+    "\n",
+    "\n",
+    "def user_prompt_for(website):\n",
+    "    user_prompt = f\"You are looking at a website titled {website.title}\"\n",
+    "    user_prompt += \"\\nThe contents of this website is as follows; \\\n",
+    "                    please provide a short summary of this website in markdown. \\\n",
+    "                    If it includes news or announcements, then summarize these too.\\n\\n\"\n",
+    "    user_prompt += website.text\n",
+    "    return user_prompt\n",
+    "\n",
+    "\n",
+    "def messages_for(website):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_prompt},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(website)}\n",
+    "    ]\n",
+    "\n",
+    "\n",
+    "def summary(url):\n",
+    "    website = Website(url)\n",
+    "    response = ollama.chat(\n",
+    "        model = MODEL,\n",
+    "        messages = messages_for(website)\n",
+    "    )\n",
+    "    return display(Markdown(response['message']['content']))\n",
+    "\n",
+    "\n",
+    "summary(\"https://edwarddonner.com\")\n",
+    "# summary(\"https://cnn.com\")\n",
+    "# summary(\"https://anthropic.com\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/community-contributions/Ollama brochure.ipynb

@@ -0,0 +1,432 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "b56a950c-db41-4575-bef9-0fa651dea363",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import requests\n",
+    "import json\n",
+    "import ollama\n",
+    "from typing import List\n",
+    "from bs4 import BeautifulSoup\n",
+    "from IPython.display import Markdown, display, update_display,clear_output\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ec875db-0f6a-4eec-a3b6-eae4b71a4b89",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Constants\n",
+    "\n",
+    "MODEL = \"llama3.2\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "227cd07c-98a4-463b-94ad-94e33d04944b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A class to represent a Webpage\n",
+    "\n",
+    "# Some websites need you to use proper headers when fetching them:\n",
+    "headers = {\n",
+    " \"User-Agent\": \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36\"\n",
+    "}\n",
+    "\n",
+    "class Website:\n",
+    "    \"\"\"\n",
+    "    A utility class to represent a Website that we have scraped, now with links\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, url):\n",
+    "        self.url = url\n",
+    "        response = requests.get(url, headers=headers)\n",
+    "        self.body = response.content\n",
+    "        soup = BeautifulSoup(self.body, 'html.parser')\n",
+    "        self.title = soup.title.string if soup.title else \"No title found\"\n",
+    "        if soup.body:\n",
+    "            for irrelevant in soup.body([\"script\", \"style\", \"img\", \"input\"]):\n",
+    "                irrelevant.decompose()\n",
+    "            self.text = soup.body.get_text(separator=\"\\n\", strip=True)\n",
+    "        else:\n",
+    "            self.text = \"\"\n",
+    "        links = [link.get('href') for link in soup.find_all('a')]\n",
+    "        self.links = [link for link in links if link]\n",
+    "\n",
+    "    def get_contents(self):\n",
+    "        return f\"Webpage Title:\\n{self.title}\\nWebpage Contents:\\n{self.text}\\n\\n\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4d5c5e40-c010-4102-8359-899f988185fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ed = Website(\"https://edwarddonner.com\")\n",
+    "ed.links"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f0b5d71-487c-47a5-ace6-8e02465ed452",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "link_system_prompt = \"You are provided with a list of links found on a webpage. \\\n",
+    "You are able to decide which of the links would be most relevant to include in a brochure about the company, \\\n",
+    "such as links to an About page, or a Company page, or Careers/Jobs pages.\\n\"\n",
+    "link_system_prompt += \"You should respond in JSON as in this example:\"\n",
+    "link_system_prompt += \"\"\"\n",
+    "{\n",
+    "    \"links\": [\n",
+    "        {\"type\": \"about page\", \"url\": \"https://full.url/goes/here/about\"},\n",
+    "        {\"type\": \"careers page\": \"url\": \"https://another.full.url/careers\"}\n",
+    "    ]\n",
+    "}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c6550325-5160-42c9-b7e7-980b504cd096",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(link_system_prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2db4ccc6-5c35-4775-a5b2-4b86e4c73808",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_links_user_prompt(website):\n",
+    "    user_prompt = f\"Here is the list of links on the website of {website.url} - \"\n",
+    "    user_prompt += \"please decide which of these are relevant web links for a brochure about the company, respond with the full https URL in JSON format. \\\n",
+    "Do not include Terms of Service, Privacy, email links.\\n\"\n",
+    "    user_prompt += \"Links (some might be relative links):\\n\"\n",
+    "    user_prompt += \"\\n\".join(website.links)\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8af511c7-5a74-4d1a-b763-b31370e70cff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(get_links_user_prompt(ed))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a3b7fb61-ca15-4eab-b017-b0fe5cce46fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_links(url):\n",
+    "    website = Website(url)\n",
+    "    response = ollama.chat(\n",
+    "        model=MODEL,\n",
+    "        messages=[\n",
+    "            {\"role\": \"system\", \"content\": link_system_prompt},\n",
+    "            {\"role\": \"user\", \"content\": get_links_user_prompt(website)}\n",
+    "        ], format = \"json\"  #Define format as json!\n",
+    "    )\n",
+    "    result = response['message']['content']\n",
+    "\n",
+    "    return json.loads(result)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7816d393-620d-4c53-913e-4ec130b2baba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Anthropic has made their site harder to scrape, so I'm using HuggingFace..\n",
+    "\n",
+    "anthropic = Website(\"https://anthropic.com\")\n",
+    "anthropic.links"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f32ceccb-1d45-41a3-a5c1-fb2e6cd76afe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "get_links(\"https://anthropic.com\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7ec4727-e897-473c-a657-e74f6999c974",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_all_details(url):\n",
+    "    result = \"Landing page:\\n\"\n",
+    "    result += Website(url).get_contents()\n",
+    "    links = get_links(url)\n",
+    "    print(\"Found links:\", links)\n",
+    "    for link in links[\"links\"]:\n",
+    "        result += f\"\\n\\n{link['type']}\\n\"\n",
+    "        result += Website(link[\"url\"]).get_contents()\n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7acde0c5-1af2-4e8e-9303-e2a98ec9cdbb",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "print(get_all_details(\"https://anthropic.com\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a2e2b1d-eb55-4bfb-bf55-5e8c87db0d96",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_prompt = \"You are an assistant that analyzes the contents of several relevant pages from a company website \\\n",
+    "and creates a short brochure about the company for prospective customers, investors and recruits. Respond in markdown.\\\n",
+    "Include details of company culture, customers and careers/jobs if you have the information.\"\n",
+    "\n",
+    "# Or uncomment the lines below for a more humorous brochure - this demonstrates how easy it is to incorporate 'tone':\n",
+    "\n",
+    "# system_prompt = \"You are an assistant that analyzes the contents of several relevant pages from a company website \\\n",
+    "# and creates a short humorous, entertaining, jokey brochure about the company for prospective customers, investors and recruits. Respond in markdown.\\\n",
+    "# Include details of company culture, customers and careers/jobs if you have the information.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8eac1719-7f94-4460-bc4a-0c9c93bb17a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_brochure_user_prompt(company_name, url):\n",
+    "    user_prompt = f\"You are looking at a company called: {company_name}\\n\"\n",
+    "    user_prompt += f\"Here are the contents of its landing page and other relevant pages; use this information to build a short brochure of the company in markdown.\\n\"\n",
+    "    user_prompt += get_all_details(url)\n",
+    "    user_prompt = user_prompt[:5_000] # Truncate if more than 5,000 characters\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e2e312f6-01c5-4e57-9134-fb4aa447d155",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "get_brochure_user_prompt(\"Anthropic\", \"https://anthropic.com\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8b05cbab-f0d2-4a9e-8b8c-c868a036e9cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_brochure(company_name, url):\n",
+    "    response = ollama.chat(\n",
+    "        model=MODEL,\n",
+    "        messages=[\n",
+    "            {\"role\": \"system\", \"content\": system_prompt},\n",
+    "            {\"role\": \"user\", \"content\": get_brochure_user_prompt(company_name, url)}\n",
+    "        ]\n",
+    "    )\n",
+    "    result = response[\"message\"][\"content\"]\n",
+    "    display(Markdown(result))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "91ede0c0-daf2-42ef-9d31-749afb9d5352",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "create_brochure(\"Anthropic\", \"https://anthropic.com\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "afb4aeee-5108-42a7-a1c1-5bad254b7e8b",
+   "metadata": {},
+   "source": [
+    "# Final omprovement\n",
+    "\n",
+    "getting a typewriter animation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "177de611-1cb1-49e2-b7ea-8d01191af3ee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_brochure(company_name, url):\n",
+    "    messages = [\n",
+    "        {\"role\": \"system\", \"content\": system_prompt},\n",
+    "        {\"role\": \"user\", \"content\": get_brochure_user_prompt(company_name, url)}\n",
+    "    ]\n",
+    "\n",
+    "    display_markdown = display(Markdown(\"\"), display_id=True)  # Initialize Markdown display\n",
+    "    response_text = \"\"\n",
+    "\n",
+    "    for chunk in ollama.chat(model=MODEL, messages=messages, stream=True):  # Ensure stream=True (not a string)\n",
+    "        response_text += chunk['message']['content']\n",
+    "        clear_output(wait=True)  # Clear previous output to create a streaming effect\n",
+    "        display_markdown.update(Markdown(response_text))  # Update Markdown dynamically\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "a1971d81-fc7f-4ed1-97a0-7ef5e8ed332a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found links: {'links': [{'type': 'About page', 'url': 'https://www.anthropic.com/company'}, {'type': 'Careers page', 'url': 'https://www.anthropic.com/careers'}, {'type': 'Company page', 'url': 'https://www.anthropic.com/'}, {'type': 'Research page', 'url': 'https://www.anthropic.com/research'}, {'type': 'Twitter profile', 'url': 'https://twitter.com/AnthropicAI'}, {'type': 'LinkedIn company page', 'url': 'https://www.linkedin.com/company/anthropicresearch'}, {'type': 'YouTube channel', 'url': 'https://www.youtube.com/@anthropic-ai'}]}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**Anthropic Brochure**\n",
+       "======================\n",
+       "\n",
+       "**Mission Statement**\n",
+       "-------------------\n",
+       "\n",
+       "Anthropic is an AI safety and research company dedicated to building reliable, interpretable, and steerable AI systems that benefit humanity in the long run.\n",
+       "\n",
+       "**Company Overview**\n",
+       "--------------------\n",
+       "\n",
+       "Anthropic is headquartered in San Francisco and brings together a diverse team of researchers, engineers, policy experts, and business leaders with experience spanning various disciplines. Our mission is to conduct frontier AI research, develop and apply safety techniques, and deploy the resulting systems via partnerships and products.\n",
+       "\n",
+       "**Research Focus**\n",
+       "-----------------\n",
+       "\n",
+       "Anthropic conducts cutting-edge AI research across various modalities, exploring novel and emerging safety research areas such as interpretability, RL from human feedback, policy, and societal impacts analysis. Our research aims to advance the field of AI safety and inform our product development.\n",
+       "\n",
+       "**Product Portfolio**\n",
+       "---------------------\n",
+       "\n",
+       "Our flagship product is Claude, a highly intelligent AI model that enables customers to build custom applications and experiences using our API. We also offer various enterprise solutions, including Claude for Enterprise, designed to meet the needs of large organizations.\n",
+       "\n",
+       "**Customer Base**\n",
+       "-----------------\n",
+       "\n",
+       "Anthropic serves a diverse range of customers, including businesses, nonprofits, civil society groups, and their clients around the globe. Our commitment to safety and reliability has earned us a reputation as a trusted partner in the AI industry.\n",
+       "\n",
+       "**Values and Culture**\n",
+       "----------------------\n",
+       "\n",
+       "At Anthropic, we value:\n",
+       "\n",
+       "*   **Acting for the global good**: We strive to make decisions that maximize positive outcomes for humanity in the long run.\n",
+       "*   **Holding light and shade**: We acknowledge the potential risks of AI and approach our work with caution and transparency.\n",
+       "\n",
+       "**Join Our Team**\n",
+       "-----------------\n",
+       "\n",
+       "We're a collaborative team of researchers, engineers, policy experts, and business leaders passionate about building safer AI systems. Join us to be part of this exciting journey and contribute your skills and expertise to shaping the future of AI.\n",
+       "\n",
+       "**Careers**\n",
+       "------------\n",
+       "\n",
+       "Check our website for open roles and learn more about our company culture, benefits, and career opportunities.\n",
+       "\n",
+       "[Learn More](link)\n",
+       "\n",
+       "**Get in Touch**\n",
+       "-----------------\n",
+       "\n",
+       "Stay up-to-date with the latest news and announcements from Anthropic. Follow us on Twitter, LinkedIn, or YouTube to join the conversation and stay informed.\n",
+       "\n",
+       "[Twitter](link)\n",
+       "[LinkedIn](link)\n",
+       "[YouTube](link)"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "create_brochure(\"Anthropic\", \"https://anthropic.com\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c33277a4-84f1-447c-a66e-eb7e2af42d2a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/community-contributions/OllamaDay1_MailSubjectLine.ipynb

@@ -0,0 +1,83 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce3db287-8661-4649-a599-cba0edd115b1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import os\n",
+    "import requests\n",
+    "from dotenv import load_dotenv\n",
+    "from bs4 import BeautifulSoup\n",
+    "from IPython.display import Markdown, display\n",
+    "from openai import OpenAI\n",
+    "\n",
+    "openai = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
+    "system_prompt = \"You are an assistant that analyzes the contents of an email\"\n",
+    "user_prompt = \"Provide a short subject line which aligns with the body of the email\"\n",
+    "email_content = \"\"\"\n",
+    "From: [email protected]\n",
+    "To: [email protected]\n",
+    "Subject: \n",
+    "\n",
+    "Hi Team,\n",
+    "\n",
+    "This email provides an update on Project Alpha. We've successfully completed Phase 1, which involved, and would like to thank all the \n",
+    "team for the great work, and looking forward to the same energy and rigor for Phase 2 too. \n",
+    "\n",
+    "Keep up the good work!! \n",
+    "\n",
+    "Thanks,\n",
+    "James\n",
+    "\"\"\"\n",
+    "\n",
+    "# Step 2: Make the messages list\n",
+    "\n",
+    "messages = [\n",
+    "    {\"role\": \"system\", \"content\": system_prompt},\n",
+    "    {\"role\": \"user\", \"content\": user_prompt+email_content}\n",
+    "]\n",
+    "\n",
+    "# Step 3: Call OpenAI\n",
+    "\n",
+    "#response =\n",
+    "response = openai.chat.completions.create(model=\"llama3.2\", messages=messages)\n",
+    "\n",
+    "# Step 4: print the result\n",
+    "print(response.choices[0].message.content)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "526b87f1-aa38-44d4-9609-292a4f4d72a9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/community-contributions/Ollama_websummarizer_user_input.ipynb

@@ -0,0 +1,240 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9964872b-225d-4ced-93e4-fc5b279ec2ed",
+   "metadata": {},
+   "source": [
+    "# Webpage English summarizer with user inputs (url, ollama-based LLM) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4e49d399-d18c-4c91-8abc-cf3289e11e2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import requests\n",
+    "# from dotenv import load_dotenv\n",
+    "from bs4 import BeautifulSoup\n",
+    "from IPython.display import Markdown, display\n",
+    "from openai import OpenAI\n",
+    "import ollama, time\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "46e7d809-248d-41b8-80e1-36b210041581",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define system prompt.\n",
+    "\n",
+    "system_prompt = \"You are an assistant that analyzes the contents of a website \\\n",
+    "and provides a detailed summary, ignoring text that might be navigation related. \\\n",
+    "Respond in markdown, in English.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8bf237f-591f-4c32-9415-5d5d4e2522b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A function that writes a User Prompt that asks for summaries of websites:\n",
+    "\n",
+    "def user_prompt_for(website):\n",
+    "    user_prompt = f\"You are looking at a website titled {website.title}\"\n",
+    "    user_prompt += \"\\nThe contents of this website is as follows; \\\n",
+    "please provide a detailed summary of this website in markdown. \\\n",
+    "If it includes news or announcements, then summarize these too.\\n\\n\"\n",
+    "    user_prompt += website.text\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7d39ee6d-c670-41ba-a0b8-debd55bda8e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# See how this function creates exactly the format above\n",
+    "\n",
+    "def messages_for(website):\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_prompt},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt_for(website)}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43e28ff5-2def-4a47-acdd-2e06c0666956",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Constants\n",
+    "\n",
+    "OLLAMA_API = \"http://localhost:11434/api/chat\"\n",
+    "HEADERS = {\"Content-Type\": \"application/json\"}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "32f4f481-81a3-479d-817b-4e754d9af46d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A class to represent a Webpage\n",
+    "# If you're not familiar with Classes, check out the \"Intermediate Python\" notebook\n",
+    "\n",
+    "# Some websites need you to use proper headers when fetching them:\n",
+    "headers = HEADERS\n",
+    "\n",
+    "class Website:\n",
+    "\n",
+    "    def __init__(self, url):\n",
+    "        \"\"\"\n",
+    "        Create this Website object from the given url using the BeautifulSoup library\n",
+    "        \"\"\"\n",
+    "        self.url = url\n",
+    "        response = requests.get(url, headers=headers)\n",
+    "        soup = BeautifulSoup(response.content, 'html.parser')\n",
+    "        self.title = soup.title.string if soup.title else \"No title found\"\n",
+    "        for irrelevant in soup.body([\"script\", \"style\", \"img\", \"input\"]):\n",
+    "            irrelevant.decompose()\n",
+    "        self.text = soup.body.get_text(separator=\"\\n\", strip=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f81cfd17-8208-4192-a59f-485ff3ea74e4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# And now: call the ollama API wrapper and return the relevant component of the response\n",
+    "\n",
+    "def summarize(url):\n",
+    "    website = Website(url)\n",
+    "    response = ollama.chat(\n",
+    "        model=MODEL,\n",
+    "        messages = messages_for(website)\n",
+    "    )\n",
+    "    return response['message']['content']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7a9eedc6-2183-473d-84ca-b10d40e2a1e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Ask the user the name of the url address\n",
+    "\n",
+    "url= str(input(\"\"\"\n",
+    "Please provide a valid url address:\n",
+    "https://\"\"\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5d012de2-0ef2-43db-9f51-fc7f989c3642",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Ask the user to select a valid model\n",
+    "\n",
+    "MODEL= str(input(\"\"\"\n",
+    "Please select a LLM:\n",
+    "(examples: llama3.2, deepseek-r1:1.5b)\n",
+    "\"\"\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ac8c02e-4a62-448b-a231-8c6f65891811",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Let's just make sure the model is loaded\n",
+    "\n",
+    "!ollama pull {MODEL}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0544541f-11a8-4eb7-8eb6-bc032ed6d0d1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print('url: https://{0}\\nModel= {1}'.format(url, MODEL))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "45518950-f2c9-43af-b897-4fe8fe48dfd8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "summary = summarize('https://'+ url)\n",
+    "for summ in tqdm(summary):\n",
+    "    time.sleep(0.01)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "02c0c15e-216d-47c7-843d-ac27af02820b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "display(Markdown(summary))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "985a3689-5827-4b15-b8d5-276f9b292afd",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/community-contributions/Text-Summarizer.ipynb

@@ -0,0 +1,76 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 1) Import Required Libraries \n",
+    "\n",
+    "import requests\n",
+    "import gradio as gr\n",
+    "\n",
+    "# Deepseek only uses abstract summarization\n",
+    "# This tool use DeepSeek API Endpoint\n",
+    "\n",
+    "# 2) Define the DeepSeek API Endpoint\n",
+    "\n",
+    "OLLAMA_URL = \"http://localhost:11434/api/generate\"\n",
+    "\n",
+    "# 3) Define the Summarization Function which can retrieve Information\n",
+    "\n",
+    "def summarize_text(text):\n",
+    "    payload = {\n",
+    "        \"model\": \"deepseek-r1\", #Here you can load whatever the model you have in your ollama(ex:deepseek-r1:1.5b,7b,8b,14b) I used 7b model here \n",
+    "        \"prompt\": f\"Summarize the following text in **5 bullet points**:\\n\\n{text}\", #The prompt is here for tell commands for the llm to act \n",
+    "        \"stream\": False  # Ensures the response is returned as a whole, not streamed\n",
+    "    }\n",
+    "\n",
+    "    response = requests.post(OLLAMA_URL, json=payload) #Send Requests to deepseekAPI\n",
+    "\n",
+    "    if response.status_code == 200: #if server run correctly it return the result or it will give error\n",
+    "        return response.json().get(\"response\", \"No summary generated.\")\n",
+    "    else:\n",
+    "        return f\"Error: {response.text}\"\n",
+    "\n",
+    "# 4) Create Gradio interface to design \n",
+    "interface = gr.Interface(\n",
+    "    fn=summarize_text,\n",
+    "    inputs=gr.Textbox(lines=10, placeholder=\"Enter text to summarize\"),\n",
+    "    outputs=gr.Textbox(label=\"Summarized Text\"),\n",
+    "    #theme='NoCrypt/miku', #Theme for the Interface I used Hatsune Miku from HF \n",
+    "    title=\"AI-Powered Text Summarizer\",\n",
+    "    description=\"Enter a long text and DeepSeek AI will generate a concise summary.\"\n",
+    ")\n",
+    "\n",
+    "# Launch the web app\n",
+    "if __name__ == \"__main__\":\n",
+    "    interface.launch()\n",
+    "\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

week1/community-contributions/W1D5_Code_instructor.ipynb

@@ -0,0 +1,269 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0e5dc476-e3c9-49bd-934a-35dbe0d55b13",
+   "metadata": {},
+   "source": [
+    "# End of week 1 exercise (with user input(question, model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "353fba18-a9b4-4ba8-be7e-f3e3c37521ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import requests\n",
+    "from dotenv import load_dotenv\n",
+    "from bs4 import BeautifulSoup\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "from openai import OpenAI\n",
+    "import ollama"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "be2b859d-b3d2-41f7-8666-28ecde26e3b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# set up environment and constants\n",
+    "load_dotenv(override=True)\n",
+    "api_key = os.getenv('OPENAI_API_KEY')\n",
+    "\n",
+    "if api_key and api_key.startswith('sk-proj-') and len(api_key)>10:\n",
+    "    print(\"API key looks good so far\")\n",
+    "else:\n",
+    "    print(\"There might be a problem with your API key? Please visit the troubleshooting notebook!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1b2b694-11a1-4d2a-8e34-d1fb02617fa3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_prompt = \"You are an expert coder with educational skills for beginners. \\\n",
+    "You are able to explain, debbug or generate code in Python, R or bash, and to provide examples of use case if applicable. \\\n",
+    "Please add references to relevant sources if available. If not, do not invent.\\n\"\n",
+    "system_prompt += \"this is an example of a response:\"\n",
+    "system_prompt += \"\"\"\n",
+    "Sure! Here’s the explanation in plain text format, suitable for Markdown:\n",
+    "\n",
+    "# Explanation of the Code\n",
+    "\n",
+    "### Code:\n",
+    "```python\n",
+    "full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'\n",
+    "```\n",
+    "\n",
+    "### Explanation:\n",
+    "\n",
+    "1. **Lambda Function:**\n",
+    "   - The keyword `lambda` is used to create a small, one-line anonymous function (a function without a name).\n",
+    "   - It takes two parameters: `first` (for the first name) and `last` (for the last name).\n",
+    "\n",
+    "2. **String Formatting (`f-string`):**\n",
+    "   - `f'Full name: {first.title()} {last.title()}'` is a formatted string (f-string).\n",
+    "   - It inserts the values of `first` and `last` into the string while applying `.title()` to capitalize the first letter of each name.\n",
+    "\n",
+    "3. **Assigning the Function:**\n",
+    "   - The lambda function is assigned to the variable `full_name`, so we can use `full_name()` like a regular function.\n",
+    "\n",
+    "### How to Use It:\n",
+    "Now, let’s call this function and see what it does.\n",
+    "\n",
+    "```python\n",
+    "print(full_name(\"john\", \"doe\"))\n",
+    "```\n",
+    "\n",
+    "#### Output:\n",
+    "```\n",
+    "Full name: John Doe\n",
+    "```\n",
+    "\n",
+    "### What Happens:\n",
+    "- `\"john\"` becomes `\"John\"` (because `.title()` capitalizes the first letter).\n",
+    "- `\"doe\"` becomes `\"Doe\"`.\n",
+    "- The output is `\"Full name: John Doe\"`.\n",
+    "\n",
+    "### Summary:\n",
+    "This is a simple way to create a function that formats a full name while ensuring proper capitalization. You could write the same function using `def` like this:\n",
+    "\n",
+    "```python\n",
+    "def full_name(first, last):\n",
+    "    return f'Full name: {first.title()} {last.title()}'\n",
+    "```\n",
+    "\n",
+    "Both versions work the same way, but the `lambda` version is more compact.\n",
+    "\n",
+    "### Reference(s):\n",
+    "To deepen your understanding of the code snippet involving Python's lambda functions here is a resource you might find helpful:\n",
+    "\n",
+    "Ref. **Python Lambda Functions:**\n",
+    "   - The official Python documentation provides an in-depth explanation of lambda expressions, including their syntax and use cases.\n",
+    "     - [Lambda Expressions](https://docs.python.org/3/tutorial/controlflow.html#lambda-expressions)\n",
+    "\n",
+    "```\n",
+    "You can copy and paste this into any Markdown file or viewer. Let me know if you need further modifications! 😊\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f7225ab0-5ade-4c93-839c-3c80b0b23c37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# display(Markdown(system_prompt))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "07fa2506-4b24-4a53-9f3f-500b4cbcb10a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# user question\n",
+    "default_question= \"\"\"\n",
+    "Please explain what this code does and why:\n",
+    "yield from {book.get('author') from book in books if book.get('author')}\n",
+    "\"\"\"\n",
+    "user_question= str(input(\"What code do you want me to explain?/n(Press 'Enter' for an example)\"))\n",
+    "\n",
+    "if user_question== '':\n",
+    "    question= default_question\n",
+    "    print(default_question)\n",
+    "else:\n",
+    "    question= \"Please explain what this code does and why:\\n\" + user_question"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a6749065-fb8a-4f9f-8297-3cd33abd97bd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(question)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f48df06c-edb7-4a05-9e56-910854dad0c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# user model\n",
+    "model_number= input(\"\"\"\n",
+    "Please enter the number of the model you want to use from the list below:\n",
+    "1 GPT-4o Mini\n",
+    "2 Llama 3.2\n",
+    "3 DeepSeek R1\n",
+    "4 Qwen 2.5\n",
+    "\"\"\")\n",
+    "try:\n",
+    "    if int(model_number)==1:\n",
+    "        model= 'gpt-4o-mini'\n",
+    "    elif int(model_number)==2:\n",
+    "        model= 'llama3.2'\n",
+    "    elif int(model_number)==3:\n",
+    "        model= 'deepseek-r1:1.5b'\n",
+    "    elif int(model_number)==4:\n",
+    "        model= 'qwen2.5:3b'\n",
+    "    else:\n",
+    "        model= ''\n",
+    "        print(\"please provide only a number from the list\")\n",
+    "except:\n",
+    "    model=''\n",
+    "    print(\"Please provide a number or press 'Enter' to finish\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aeb6e4e5-fb63-4192-bb74-0b015dfedfb7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# print(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fffa6021-d3f8-4855-a694-bed6d651791f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "messages=[\n",
+    "    {\"role\": \"system\", \"content\": system_prompt},\n",
+    "    {\"role\": \"user\", \"content\": question}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "835374a4-3df5-4f28-82e3-6bc70514df16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if int(model_number)==1:\n",
+    "    openai= OpenAI()\n",
+    "    stream = openai.chat.completions.create(\n",
+    "        model=model,\n",
+    "        messages=messages,\n",
+    "        stream= True\n",
+    "        )\n",
+    "\n",
+    "    response = \"\"\n",
+    "    print(\"The following answer will be generated by {0} LLM\".format(model))\n",
+    "    display_handle = display(Markdown(\"\"), display_id=True)\n",
+    "    for chunk in stream:\n",
+    "        response += chunk.choices[0].delta.content or ''\n",
+    "        response = response.replace(\"```\",\"\").replace(\"markdown\", \"\")\n",
+    "        update_display(Markdown(response), display_id=display_handle.display_id)\n",
+    "elif int(model_number)==2 or 3 or 4:\n",
+    "    !ollama pull {model}\n",
+    "    print(\"\\n\\nThe following answer will be generated by {0} LLM\\n\\n\".format(model))\n",
+    "    response = ollama.chat(\n",
+    "        model=model,\n",
+    "        messages = messages)\n",
+    "    result= response['message']['content']\n",
+    "    display(Markdown(result))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/community-contributions/Week1-Challenge-Brochure-Translation.ipynb

@@ -0,0 +1,346 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5787d599-798e-4161-a473-970e8d948db3",
+   "metadata": {},
+   "source": [
+    "# Community contribution\n",
+    "\n",
+    "Generating a sports brochure - and then in Spanish! Many thanks for the contribution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ed9b1c0-50dc-48ea-b1b6-6be3264255b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "\n",
+    "import os\n",
+    "import requests\n",
+    "import json\n",
+    "from typing import List\n",
+    "from dotenv import load_dotenv\n",
+    "from bs4 import BeautifulSoup\n",
+    "from IPython.display import Markdown, display, update_display\n",
+    "from openai import OpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "23cc579a-43eb-44b5-8105-8ec3d46ec029",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialize and constants\n",
+    "\n",
+    "load_dotenv()\n",
+    "os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', 'your-key-if-not-using-env')\n",
+    "MODEL = 'gpt-4o-mini'\n",
+    "openai = OpenAI()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0206cf1d-00c5-401d-8aa0-88a83aeb8c83",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# A class to represent a Webpage\n",
+    "\n",
+    "class Website:\n",
+    "    url: str\n",
+    "    title: str\n",
+    "    body: str\n",
+    "    links: List[str]\n",
+    "\n",
+    "    def __init__(self, url):\n",
+    "        self.url = url\n",
+    "        response = requests.get(url)\n",
+    "        self.body = response.content\n",
+    "        soup = BeautifulSoup(self.body, 'html.parser')\n",
+    "        self.title = soup.title.string if soup.title else \"No title found\"\n",
+    "        if soup.body:\n",
+    "            for irrelevant in soup.body([\"script\", \"style\", \"img\", \"input\"]):\n",
+    "                irrelevant.decompose()\n",
+    "            self.text = soup.body.get_text(separator=\"\\n\", strip=True)\n",
+    "        else:\n",
+    "            self.text = \"\"\n",
+    "        links = [link.get('href') for link in soup.find_all('a')]\n",
+    "        self.links = [link for link in links if link]\n",
+    "\n",
+    "    def get_contents(self):\n",
+    "        return f\"Webpage Title:\\n{self.title}\\nWebpage Contents:\\n{self.text}\\n\\n\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1ab939b-0a81-4301-8820-abdc1b740a86",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "caps = Website(\"https://www.nhl.com/capitals/\")\n",
+    "print(caps.get_contents())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6bc9763c-e8cb-47f4-a5f0-fccbdb34f5f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(caps.links)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11a407e0-6d23-4199-bb58-344352178978",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "link_system_prompt = \"You are provided with a list of links found on a webpage. \\\n",
+    "You are able to decide which of the links would be most relevant to include in a brochure about the team, \\\n",
+    "such as links to an About page, Team, News, Schedule, History, Stats pages.\\n\"\n",
+    "link_system_prompt += \"You should respond in JSON as in this example:\"\n",
+    "link_system_prompt += \"\"\"\n",
+    "{\n",
+    "    \"links\": [\n",
+    "        {\"type\": \"about page\", \"url\": \"https://full.url/goes/here/about\"},\n",
+    "        {\"type\": \"team page\", \"url\": \"https://full.url/goes/here/team\"},\n",
+    "        {\"type\": \"news page\": \"url\": \"https://another.full.url/news\"},\n",
+    "        {\"type\": \"schedule page\": \"url\": \"https://another.full.url/schedule\"},\n",
+    "        {\"type\": \"history page\": \"url\": \"https://another.full.url/history\"},\n",
+    "        {\"type\": \"stats page\": \"url\": \"https://another.full.url/stats\"},\n",
+    "        {\"type\": \"standings page\": \"url\": \"https://another.full.url/standings\"},\n",
+    "    ]\n",
+    "}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b45c01f5-e27d-47d6-b9e7-7500940da3c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_links_user_prompt(website):\n",
+    "    user_prompt = f\"Here is the list of links on the website of {website.url} - \"\n",
+    "    user_prompt += \"please decide which of these are relevant web links for a brochure about the team, respond with the full https URL in JSON format. \\\n",
+    "Do not include Terms of Service, Privacy, Tickets, Video, Listen, Community, Fans, Youth Hockey, Shop, League, email links.\\n\"\n",
+    "    user_prompt += \"Links (some might be relative links):\\n\"\n",
+    "    user_prompt += \"\\n\".join(website.links)\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9dbfc365-b3c7-45d2-bd6d-79efb2372f43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(get_links_user_prompt(caps))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "410c113b-a5b2-4639-aace-2203a8631dbc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_links(url):\n",
+    "    website = Website(url)\n",
+    "    completion = openai.chat.completions.create(\n",
+    "        model=MODEL,\n",
+    "        messages=[\n",
+    "            {\"role\": \"system\", \"content\": link_system_prompt},\n",
+    "            {\"role\": \"user\", \"content\": get_links_user_prompt(website)}\n",
+    "      ],\n",
+    "        response_format={\"type\": \"json_object\"}\n",
+    "    )\n",
+    "    result = completion.choices[0].message.content\n",
+    "    return json.loads(result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b8a5d809-c85e-4a97-9a81-61114b635027",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "get_links(\"https://www.nhl.com/capitals/\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ffb4dbdf-758c-4180-aa4f-3c18899493eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_all_details(url):\n",
+    "    result = \"Landing page:\\n\"\n",
+    "    result += Website(url).get_contents()\n",
+    "    links = get_links(url)\n",
+    "    print(\"Found links:\", links)\n",
+    "    for link in links[\"links\"]:\n",
+    "        result += f\"\\n\\n{link['type']}\\n\"\n",
+    "        result += Website(link[\"url\"]).get_contents()\n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b7546e12-c819-4092-a783-7be23d4d7b8c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(get_all_details(\"https://www.nhl.com/capitals/\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3d9aa466-e68d-4119-95e4-10893d774ebf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_prompt = \"You are a sports marketing analyst that analyzes the contents of several relevant pages from a sports team website \\\n",
+    "and creates a short brochure about the team for prospective fans and players to recruit. Respond in markdown.\\\n",
+    "Include details of team history, team culture, team news, and team stats if you have the information.\"\n",
+    "\n",
+    "# Or uncomment the lines below for a more humorous brochure - this demonstrates how easy it is to incorporate 'tone':\n",
+    "\n",
+    "# system_prompt = \"You are an assistant that analyzes the contents of several relevant pages from a company website \\\n",
+    "# and creates a short humorous, entertaining, jokey brochure about the company for prospective customers, investors and recruits. Respond in markdown.\\\n",
+    "# Include details of company culture, customers and careers/jobs if you have the information.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "07097603-5196-47cc-9e61-b412c14b62c6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_brochure_user_prompt(company_name, url):\n",
+    "    user_prompt = f\"You are looking at a company called: {company_name}\\n\"\n",
+    "    user_prompt += f\"Here are the contents of its landing page and other relevant pages; use this information to build a short brochure of the team in markdown.\\n\"\n",
+    "    user_prompt += get_all_details(url)\n",
+    "    user_prompt = user_prompt[:40_000] # Truncate if more than 40,000 characters\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36d42b59-0a96-41b7-b9fc-02ae37659f7a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_brochure(company_name, url):\n",
+    "    response = openai.chat.completions.create(\n",
+    "        model=MODEL,\n",
+    "        messages=[\n",
+    "            {\"role\": \"system\", \"content\": system_prompt},\n",
+    "            {\"role\": \"user\", \"content\": get_brochure_user_prompt(company_name, url)}\n",
+    "          ],\n",
+    "    )\n",
+    "    result = response.choices[0].message.content\n",
+    "    display(Markdown(result))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e642228-092a-4bf5-a3c2-1ab78822453a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "create_brochure(\"Washington Capitals\", \"https://www.nhl.com/capitals\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ccee810-3a11-48ec-8a69-d12efcbeb1cd",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d392b8a2-9d1a-40bb-a8c1-5b88ad7e463d",
+   "metadata": {},
+   "source": [
+    "# Translate to Spanish"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7bc08bb5-c02e-4685-bbd1-5afa084b7f18",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_brochure_user_prompt(company_name, url):\n",
+    "    user_prompt = f\"You are looking at a company called: {company_name}\\n\"\n",
+    "    user_prompt += f\"Here are the contents of its landing page and other relevant pages; use this information to build a short brochure in spanish of the team in markdown.\\n\"\n",
+    "    user_prompt += get_all_details(url)\n",
+    "    user_prompt = user_prompt[:40_000] # Truncate if more than 40,000 characters\n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a40a2437-499a-4665-8d45-8241705477d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "create_brochure(\"Washington Capitals\", \"https://www.nhl.com/capitals\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36f5d6d7-952c-4d50-894c-9b01e29cebc8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/community-contributions/Week1-Challenge-LocalGPT.ipynb

@@ -0,0 +1,148 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "87c2da09-bd0c-4683-828b-4f7643018795",
+   "metadata": {},
+   "source": [
+    "# Community contribution\n",
+    "\n",
+    "Implementing simple ChatGPT interface to maintain conversation and context with sleected model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "77a850ed-61f8-4a0d-9c41-45781eb60bc9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "API key looks good so far\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "import ipywidgets as widgets\n",
+    "from IPython.display import Markdown, display, update_display, clear_output\n",
+    "from openai import OpenAI\n",
+    "\n",
+    "load_dotenv()\n",
+    "api_key = os.getenv('OPENAI_API_KEY')\n",
+    "\n",
+    "if api_key and api_key.startswith('sk-proj-') and len(api_key)>10:\n",
+    "    print(\"API key looks good so far\")\n",
+    "else:\n",
+    "    print(\"There might be a problem with your API key? Please visit the troubleshooting notebook!\")\n",
+    "    \n",
+    "MODEL = 'gpt-4o-mini'\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1f7f16f0-6fec-4190-882a-3fe1f0e9704a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ChatGPTInterface:\n",
+    "    def __init__(self, api_key, model, system_message=\"You are a helpful assistant. You can format your responses using Markdown.\"):\n",
+    "        self.openai = OpenAI(api_key=api_key)\n",
+    "        self.model = model\n",
+    "        self.conversation_history = [{\"role\": \"system\", \"content\": system_message}]\n",
+    "\n",
+    "        self.chat_area = widgets.Output()\n",
+    "        self.input_box = widgets.Text(placeholder=\"Enter your message here...\")\n",
+    "        self.send_button = widgets.Button(description=\"Send\")\n",
+    "        self.clear_button = widgets.Button(description=\"Clear\")\n",
+    "\n",
+    "        self.send_button.on_click(self.send_message)\n",
+    "        self.clear_button.on_click(self.clear_chat)\n",
+    "\n",
+    "        self.layout = widgets.VBox([\n",
+    "            self.chat_area,\n",
+    "            widgets.HBox([self.input_box, self.send_button, self.clear_button])\n",
+    "        ])\n",
+    "\n",
+    "    def display(self):\n",
+    "        display(self.layout)\n",
+    "\n",
+    "    def send_message(self, _):\n",
+    "        user_message = self.input_box.value.strip()\n",
+    "        if user_message:\n",
+    "            self.conversation_history.append({\"role\": \"user\", \"content\": user_message})\n",
+    "            self.display_message(\"You\", user_message)\n",
+    "            self.input_box.value = \"\"\n",
+    "\n",
+    "            try:\n",
+    "                response = self.openai.chat.completions.create(\n",
+    "                    model=self.model,\n",
+    "                    messages=self.conversation_history\n",
+    "                )\n",
+    "                assistant_message = response.choices[0].message.content.strip()\n",
+    "                self.conversation_history.append({\"role\": \"assistant\", \"content\": assistant_message})\n",
+    "                self.display_message(\"ChatGPT\", assistant_message)\n",
+    "            except Exception as e:\n",
+    "                self.display_message(\"Error\", str(e))\n",
+    "\n",
+    "    def clear_chat(self, _):\n",
+    "        self.conversation_history = [{\"role\": \"system\", \"content\": self.conversation_history[0][\"content\"]}]\n",
+    "        self.chat_area.clear_output(wait=True)\n",
+    "\n",
+    "    def display_message(self, sender, message):\n",
+    "        self.chat_area.append_display_data(Markdown(f\"**{sender}:**\\n{message}\"))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "78287e42-8964-4da6-bd48-a7dffd0ce7dd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "54956535cb32419bbe38d2bee125992d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(Output(), HBox(children=(Text(value='', placeholder='Enter your message here...'), Button(descr…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "chat_interface = ChatGPTInterface(api_key,MODEL)\n",
+    "chat_interface.display()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/community-contributions/Week1-Day2-Ollama-Exercise.ipynb

@@ -0,0 +1,273 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fad31e32-2e42-42ae-ae63-c15d90292839",
+   "metadata": {},
+   "source": [
+    "# First Project\n",
+    "Ollama -> Summary\n",
+    "huggingface_hub -> \"facebook/m2m100_418M\" for translation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5fb79a20-a455-4d27-91a1-91958af786c1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install transformers datasets torch\n",
+    "!pip install huggingface_hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e95ac7f2-5192-4f83-acf3-61df30cd3109",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "import requests\n",
+    "from bs4 import BeautifulSoup\n",
+    "import json\n",
+    "import ollama"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12276d74-0e79-4e66-9135-1c9d1a80b943",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Website:\n",
+    "    def __init__(self, url):\n",
+    "        self.url = url\n",
+    "        response = requests.get(url)\n",
+    "        soup = BeautifulSoup(response.content, 'html.parser')\n",
+    "        self.title = soup.title.string if soup.title else \"No title found\"\n",
+    "        for irrelevant in soup.body([\"script\", \"style\", \"img\", \"input\"]):\n",
+    "            irrelevant.decompose()\n",
+    "        self.text = soup.body.get_text(separator=\"\\n\", strip=True)\n",
+    "\n",
+    "huggingface_url = \"https://huggingface.co/learn/ml-for-3d-course\"\n",
+    "huggingface_website = Website(huggingface_url)\n",
+    "\n",
+    "huggingface_data = {\n",
+    "    \"title\": huggingface_website.title,\n",
+    "    \"text\": huggingface_website.text\n",
+    "}\n",
+    "print(huggingface_data)\n",
+    "\n",
+    "with open('ml_for_3d_course_data.json', 'w') as f:\n",
+    "    json.dump(huggingface_data, f)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7d74c85c-3e09-4514-bde4-4cafc4910c52",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# huggingface_data 'text' value\n",
+    "huggingface_text = huggingface_data['text']\n",
+    "\n",
+    "# Summary\n",
+    "response_summary = ollama.chat(model=\"llama3.2:latest\", messages=[{\"role\": \"user\", \"content\": f\"Summarize the following text: {huggingface_text}\"}])\n",
+    "print(response_summary)\n",
+    "\n",
+    "# print summary\n",
+    "summary_huggingface_text = response_summary.message['content']\n",
+    "print(\"Summary Text:\", summary_huggingface_text)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d13764d5-cb76-46c5-bbe6-d132b31a9ea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# HuggingFace Translation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08405038-4115-487f-9efc-de58572453c1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Website:\n",
+    "    url: str\n",
+    "    title: str\n",
+    "    text: str\n",
+    "\n",
+    "    def __init__(self, url):\n",
+    "        self.url = url\n",
+    "        response = requests.get(url)\n",
+    "        soup = BeautifulSoup(response.content, 'html.parser')\n",
+    "        self.title = soup.title.string if soup.title else \"No title found\"\n",
+    "        for irrelevant in soup.body([\"script\", \"style\", \"img\", \"input\"]):\n",
+    "            irrelevant.decompose()\n",
+    "        self.text = soup.body.get_text(separator=\"\\n\", strip=True)\n",
+    "\n",
+    "url = \"https://huggingface.co/learn/ml-for-3d-course\"\n",
+    "website = Website(url)\n",
+    "print(website.title)  \n",
+    "print(website.text[:1000])\n",
+    "\n",
+    "data = {\n",
+    "    \"title\": website.title,\n",
+    "    \"text\": website.text\n",
+    "}\n",
+    "\n",
+    "with open('ml_for_3d_course_data.json', 'w') as f:\n",
+    "    json.dump(data, f)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0632352f-4b16-4125-83bf-f3cc3aabd659",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a85f8625-725d-4d7f-8cb7-8da4276f81cf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install sacremoses"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c800cea4-f4a4-4e41-9637-31ff11afb256",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer\n",
+    "\n",
+    "# Load the M2M100 model and tokenizer\n",
+    "model_name = \"facebook/m2m100_418M\"\n",
+    "model = M2M100ForConditionalGeneration.from_pretrained(model_name)\n",
+    "tokenizer = M2M100Tokenizer.from_pretrained(model_name)\n",
+    "\n",
+    "# Load the saved JSON file\n",
+    "with open('ml_for_3d_course_data.json', 'r') as f:\n",
+    "    data = json.load(f)\n",
+    "\n",
+    "# Extract text from the loaded data\n",
+    "text = data[\"text\"]\n",
+    "\n",
+    "# Set the source language to English and target language to Korean\n",
+    "source_lang = \"en\"\n",
+    "target_lang = \"ko\"\n",
+    "\n",
+    "# Set the language for tokenizer (important for M2M100)\n",
+    "tokenizer.src_lang = source_lang\n",
+    "tokenizer.tgt_lang = target_lang\n",
+    "\n",
+    "# Split text into smaller chunks if it's too large\n",
+    "# This step ensures we don't exceed the model's maximum length (512 tokens)\n",
+    "max_input_length = 512\n",
+    "chunks = [text[i:i+max_input_length] for i in range(0, len(text), max_input_length)]\n",
+    "\n",
+    "print(chunks)\n",
+    "# Initialize a list to hold the translated text\n",
+    "translated_chunks = []\n",
+    "\n",
+    "# Iterate through each chunk and translate it\n",
+    "for chunk in chunks:\n",
+    "    # Tokenize the chunk\n",
+    "    encoded = tokenizer(chunk, return_tensors=\"pt\", padding=True, truncation=True, max_length=512)\n",
+    "\n",
+    "    # Generate translation from the model, forcing the output to be in Korean\n",
+    "    generated_tokens = model.generate(**encoded, forced_bos_token_id=tokenizer.get_lang_id(target_lang), max_length=512)\n",
+    "\n",
+    "    # Decode the translated tokens to text\n",
+    "    translated_text = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]\n",
+    "    translated_chunks.append(translated_text)\n",
+    "\n",
+    "# Combine all translated chunks back together\n",
+    "final_translated_text = ' '.join(translated_chunks)\n",
+    "print(\"Translated Text:\", final_translated_text)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ffe0f264-a588-422f-a6e1-b60504d1e02c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import requests\n",
+    "\n",
+    "# Ollama API URL 설정\n",
+    "ollama_url = \"http://localhost:11411/v1/models/facebook/m2m100_418M/generate\"\n",
+    "\n",
+    "# 저장된 JSON 파일 로드\n",
+    "with open('ml_for_3d_course_data.json', 'r') as f:\n",
+    "    data = json.load(f)\n",
+    "\n",
+    "# 텍스트 추출\n",
+    "course_text = data[\"text\"]\n",
+    "\n",
+    "# 번역할 소스 언어 및 타겟 언어 설정\n",
+    "source_language = \"en\"\n",
+    "target_language = \"ko\"\n",
+    "\n",
+    "# 데이터 준비\n",
+    "payload = {\n",
+    "    \"input_text\": course_text,\n",
+    "    \"src_lang\": source_language,\n",
+    "    \"tgt_lang\": target_language\n",
+    "}\n",
+    "\n",
+    "# API 호출\n",
+    "response = requests.post(ollama_url, json=payload)\n",
+    "\n",
+    "# 응답 확인\n",
+    "if response.status_code == 200:\n",
+    "    translated_course_text = response.json().get(\"translated_text\", \"Translation failed\")\n",
+    "    print(\"Translated Course Text:\", translated_course_text)\n",
+    "else:\n",
+    "    print(f\"Error {response.status_code}: {response.text}\")\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

week1/community-contributions/Week1-Exercise-OllamaStream-Solution.ipynb

@@ -0,0 +1,138 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fe12c203-e6a6-452c-a655-afb8a03a4ff5",
+   "metadata": {},
+   "source": [
+    "# End of week 1 exercise Solution Ollama with streaming\n",
+    "\n",
+    "A tool that takes a technical question, and responds with an explanation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1070317-3ed9-4659-abe3-828943230e03",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Imports\n",
+    "\n",
+    "import ollama\n",
+    "import requests\n",
+    "from IPython.display import Markdown, display"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4a456906-915a-4bfd-bb9d-57e505c5093f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Constants\n",
+    "\n",
+    "MODEL_LLAMA = 'llama3.2'\n",
+    "MODEL_LLAMA1b = \"llama3.2:1b\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f0d0137-52b0-47a8-81a8-11a90a010798",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Environment\n",
+    "\n",
+    "system_prompt = \"\"\"\n",
+    "You are an assistant that takes a technical question and respond with an explanation.\n",
+    "\"\"\"\n",
+    "\n",
+    "question = \"\"\"\n",
+    "Please explain what this code does and why:\n",
+    "yield from {book.get(\"author\") for book in books if book.get(\"author\")}\n",
+    "\"\"\"\n",
+    "\n",
+    "question2 = \"\"\"\n",
+    "What is the purpose of using yield from in the following code, and how does it differ from a standard for loop with yield?\n",
+    "yield from {book.get(\"author\") for book in books if book.get(\"author\")}\n",
+    "\"\"\"\n",
+    "\n",
+    "user_prompt = \"Answer these two questions in detail please, Question1:\" + question + \"Question2:\" + question2\n",
+    "\n",
+    "def message():\n",
+    "    return [\n",
+    "        {\"role\": \"system\", \"content\": system_prompt},\n",
+    "        {\"role\": \"user\", \"content\": user_prompt}\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8f7c8ea8-4082-4ad0-8751-3301adcf6538",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Llama 3.2 answer, with streaming\n",
+    "\n",
+    "def llama():\n",
+    "    response = ollama.chat(\n",
+    "        model = MODEL_LLAMA,\n",
+    "        messages = message(),\n",
+    "        stream =True\n",
+    "    )\n",
+    "    full_response = \"\"\n",
+    "    display_handle = display(Markdown(\"\"), display_id=True)\n",
+    "    for chunk in response:\n",
+    "        content = chunk.get(\"message\", {}).get(\"content\", \"\")\n",
+    "        if content:\n",
+    "            full_response += content\n",
+    "            display_handle.update(Markdown(full_response))\n",
+    "llama()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "342a470c-9aab-4051-ad21-514dceec76eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Llama 3.2:1b answer\n",
+    "\n",
+    "def llama():\n",
+    "    response = ollama.chat(\n",
+    "        model = MODEL_LLAMA1b,\n",
+    "        messages = message()\n",
+    "    )\n",
+    "    return display(Markdown(response['message']['content']))\n",
+    "\n",
+    "llama()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}