first commit

Author: kelvinator07

.github/workflows/python-tests.yml

@@ -0,0 +1,37 @@
+name: Python Unit Tests
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+
+    - name: Install dependencies
+      run: |
+        python3 -m pip install --upgrade pip
+
+    - name: Run unit tests
+      run: |
+        echo "⚙️ Running Tests..."
+        python3 -m unittest discover -s tests -p '*_test.py' -v
+
+    - name: Check result
+      if: ${{ failure() }}
+      run: echo "❌ Some tests failed. Please review the output above."
+
+    - name: Check result on success
+      if: ${{ success() }}
+      run: echo "✅ All tests passed successfully!"

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/ 
+.venv/

README.md

@@ -0,0 +1,34 @@
+# Btrust Builders: Python Language Club Week Two Exercises
+
+## Instructions
+
+Welcome! This exercise is designed to help you practice key Python programming skills specifically for Bitcoin development. 
+Your task is to complete the `TODO` items found in the `main.py` source file.
+
+1. Fork this repository.
+2. Go to the `Actions` tab and enable github workflow for your repository by clicking `I understand my ...`
+
+<img src="https://github.com/btrust-builders/python-week-2-exercises/blob/main/enable-github-actions.png" width="700" />
+
+3. Clone your fork to your local computer.
+4. **Explore the Code**
+   - Open the `main.py` file and examine the source code.
+   - Look for code marked with `TODO`.
+5. **Complete the TODOs**
+   - Implement the missing logic where indicated.
+   - Ensure your code is readable, idiomatic, and compiles without warnings.
+6. **Test Your Code**
+   - Run the tests using:
+     ```bash
+     python3 -m unittest discover -s tests -p 'main_test.py' -v
+     ```
+7. Commit and push your changes to the `main` branch of your remote fork.
+
+8. Confirm your forked repository has a green check mark.
+
+<img src="https://github.com/btrust-builders/python-week-2-exercises/blob/main/success.png" width="300" />
+
+9. Submit your solution to this form: [Google form](https://forms.gle/5b3ETjSwdhKjePHU9).
+
+PS: You can commit and push as often as you like and GitHub Actions will re-evaluate your code every time.
+You will need to look through the auto-grader logs (in the "Actions" tab) to see what exactly you got right or wrong.

enable-github-actions.png

@@ -0,0 +1,102 @@
+def get_tx_count(tx_list):
+    """
+    TODO: Return the number of transactions in the list.
+    Input: List of transaction IDs (strings)
+    Output: Integer count
+    """
+
+def filter_large_txids(tx_list, min_length):
+    """
+    TODO: Return a list of txids with length greater than or equal to min_length.
+    Input: List of txids (strings), minimum length (int)
+    Output: Filtered list of strings
+    """
+
+def process_txids(tx_list):
+    """
+    TODO: Iterate over txids and return list of tuples (index, txid)
+    only for txids that start with 'tx'. Use enumerate, continue as needed.
+    Input: List of txids (strings)
+    Output: List of (int, string) tuples
+    """
+
+def example_while_loop(limit):
+    """
+    TODO: Using a while loop, build a list of integers from 0 up to limit.
+    Break the loop if integer reaches 5.
+    Input: Integer limit
+    Output: List of integers
+    """
+
+def unpack_tuple(block_header):
+    """
+    TODO: Unpack the tuple representing a Bitcoin block header (height, previous hash, timestamp).
+    Input: Tuple (int, str, int)
+    Output: Unpacked tuple values
+    """
+
+def dict_methods_example(block):
+    """
+    TODO: Given a dict representing a Bitcoin block with keys 'height', 'hash', and 'tx_count',
+    return three lists: keys, values, and items.
+    Input: Dict
+    Output: Tuple of (list, list, list)
+    """
+
+def multiple_assignment(a, b):
+    """
+    TODO: Demonstrate multiple assignments and swapping two variables.
+    Input: two integers
+    Output: Tuple of two ints (swapped)
+    """
+
+def set_example(addresses):
+    """
+    TODO: Given a list of Bitcoin addresses with duplicates,
+    return a set of unique addresses.
+    Input: List of strings
+    Output: Set of strings
+    """
+
+
+class BitcoinTransaction:
+    def __init__(self, txid, amount):
+        """
+        TODO: Initialize transaction with txid (string) and amount (float).
+        """
+
+    def __str__(self):
+        """
+        TODO: Return string representation: "Tx {txid} of {amount} BTC"
+        """
+
+class Wallet:
+    def __init__(self):
+        """
+        TODO: Initialize an empty list to hold transactions.
+        """
+
+    def add_tx(self, tx):
+        """
+        TODO: Add a BitcoinTransaction to the wallet's transaction list.
+        """
+
+    def total_balance(self):
+        """
+        TODO: Calculate and return the sum of amounts of all transactions.
+        Output: Float
+        """
+
+
+def txid_generator(tx_list):
+    """
+    TODO: Yield each txid from the list one by one.
+    Input: List of strings
+    """
+
+def filter_txids_gen(tx_list, prefix="tx"):
+    """
+    TODO: Yield txids from list that start with given prefix.
+    Default prefix is 'tx'.
+    Input: List of strings, prefix string
+    """

main.py

@@ -0,0 +1,74 @@
+import unittest
+from main import *
+
+class TestBitcoinFunctions(unittest.TestCase):
+    def test_get_tx_count(self):
+        self.assertEqual(get_tx_count(["tx1", "tx2"]), 2)
+        self.assertEqual(get_tx_count([]), 0)
+
+    def test_filter_large_txids(self):
+        txs = ["tx1", "transaction2", "tx3"]
+        filtered = filter_large_txids(txs, 4)
+        self.assertEqual(filtered, ["transaction2"])
+
+    def test_process_txids(self):
+        txs = ["tx1", "abc", "tx3"]
+        result = process_txids(txs)
+        self.assertEqual(result, [(0, "tx1"), (2, "tx3")])
+
+    def test_example_while_loop(self):
+        self.assertEqual(example_while_loop(3), [0, 1, 2])
+        self.assertEqual(example_while_loop(10), [0, 1, 2, 3, 4])
+
+    def test_unpack_tuple(self):
+        header = (123456, "0000000000000000000a7b7e", 1623456789)
+        height, prev_hash, timestamp = unpack_tuple(header)
+        self.assertEqual(height, 123456)
+        self.assertTrue(prev_hash.startswith("0000"))
+        self.assertIsInstance(timestamp, int)
+
+    def test_dict_methods_example(self):
+        block = {
+            "height": 123456,
+            "hash": "0000000000000000000a7b7e",
+            "tx_count": 2500,
+        }
+        keys, values, items = dict_methods_example(block)
+        self.assertIn("height", keys)
+        self.assertIn(123456, values)
+        self.assertIn(("tx_count", 2500), items)
+
+    def test_multiple_assignment(self):
+        a, b = multiple_assignment(1, 2)
+        self.assertEqual((a, b), (2, 1))
+
+    def test_set_example(self):
+        addresses = ["addr1", "addr2", "addr1", "addr3"]
+        s = set_example(addresses)
+        self.assertIsInstance(s, set)
+        self.assertEqual(len(s), 3)
+
+    def test_bitcoin_transaction_and_wallet(self):
+        tx1 = BitcoinTransaction("tx123", 0.5)
+        tx2 = BitcoinTransaction("tx456", 1.0)
+        wallet = Wallet()
+        wallet.add_tx(tx1)
+        wallet.add_tx(tx2)
+        self.assertEqual(str(tx1), "Tx tx123 of 0.5 BTC")
+        self.assertAlmostEqual(wallet.total_balance(), 1.5)
+
+    def test_txid_generator(self):
+        txs = ["tx1", "tx2"]
+        gen = txid_generator(txs)
+        self.assertEqual(next(gen), "tx1")
+        self.assertEqual(next(gen), "tx2")
+        with self.assertRaises(StopIteration):
+            next(gen)
+
+    def test_filter_txids_gen(self):
+        txs = ["tx1", "abc", "tx3"]
+        gen = filter_txids_gen(txs)
+        self.assertEqual(list(gen), ["tx1", "tx3"])
+
+if __name__ == "__main__":
+    unittest.main()