{"id":25841925,"url":"https://github.com/courseworks/aut_ap_2024_spring_hw1","last_synced_at":"2026-07-02T12:39:08.037Z","repository":{"id":225465065,"uuid":"766058408","full_name":"courseworks/AUT_AP_2024_Spring_HW1","owner":"courseworks","description":"The first assignment for AUT's Advanced Programming course (Spring 2024), It includes a bash script for directory backups and logging, and a C++ module for matrix operations in the algebra namespace. Both tasks focus on enhancing automation, system administration, and programming skills.","archived":false,"fork":false,"pushed_at":"2024-05-03T12:12:53.000Z","size":92,"stargazers_count":19,"open_issues_count":0,"forks_count":7,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-10-30T08:50:58.364Z","etag":null,"topics":["bash-scripting","cpp-programming","homework","linear-algebra"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/courseworks.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-03-02T08:11:59.000Z","updated_at":"2025-07-04T11:55:09.000Z","dependencies_parsed_at":"2024-05-03T13:44:30.849Z","dependency_job_id":"14bb1f5b-8677-45b0-be92-c00c452c2b59","html_url":"https://github.com/courseworks/AUT_AP_2024_Spring_HW1","commit_stats":null,"previous_names":["courseworks/aut_ap_2024_spring_hw1"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/courseworks/AUT_AP_2024_Spring_HW1","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/courseworks%2FAUT_AP_2024_Spring_HW1","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/courseworks%2FAUT_AP_2024_Spring_HW1/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/courseworks%2FAUT_AP_2024_Spring_HW1/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/courseworks%2FAUT_AP_2024_Spring_HW1/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/courseworks","download_url":"https://codeload.github.com/courseworks/AUT_AP_2024_Spring_HW1/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/courseworks%2FAUT_AP_2024_Spring_HW1/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":35048062,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-07-02T02:00:06.368Z","response_time":173,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["bash-scripting","cpp-programming","homework","linear-algebra"],"created_at":"2025-03-01T05:32:48.630Z","updated_at":"2026-07-02T12:39:07.989Z","avatar_url":"https://github.com/courseworks.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003ch1 align=\"center\"\u003e\n\u003cstrong\u003eAUT_AP_2024_Spring Homework 1\u003c/strong\u003e\n\u003c/h1\u003e\n\n\u003cp align=\"center\"\u003e\n\u003cstrong\u003e Deadline: 19th of Esfand - 23:59 o'clock\u003c/strong\u003e\n\u003c/p\u003e\n\n# **1\u003csup\u003est\u003c/sup\u003e Part: Backup Script Development**\n\nThe first part of your assignment focuses on the creation of a shell script designed to efficiently perform backup operations and generate comprehensive logs. By completing this task, you'll gain hands-on experience in scripting for backup solutions, enhancing your skills in automation and system administration.\n\n## **Objective**\n\nDevelop a bash shell script capable of:\n\n- Executing backup operations for specified directories. The script will backup everything within the `Source Path`, put them all in a zip file, and put the zip file within the `Destination Path`.\n- Generating detailed logs covering various aspects of the backup process, such as file specifics, timestamps, and system data.\n\n## **Script Creation**\n\n### **Getting Started**\n\n- **Script File Location:** Find the `backup_script.sh` in the provided `bash` folder. This is where you'll write your script.\n- **Make Executable:** Ensure `backup_script.sh` is executable. Use `chmod +x backup_script.sh` in the `bash` folder, if necessary.\n\n### **Script Requirements**\n\n- **Shebang Line:** Begin your script with `#!/bin/bash` to specify the use of Bash.\n- **Input Validation:** Your script must accept three parameters:\n\n  - **Source Path:** The directory to back up (required).\n  - **Destination Path:** Where the backup will be stored (required).\n  - **Compression Level:** Denote with `-c` or `--compression` and a value. (Optional, The default is 1)\n\n  Display an error message and exit if the required inputs are not provided.\n\n- **Backup Operation:** Utilize `zip` to back up the target directory. Format the backup file as `YYYY-MM-DD_directoryname.zip` and save it to the chosen destination path, where `YYYY-MM-DD` is the date of the backup and `directoryname` is the name of the directory being backed up.\n- **Error Handling:** Terminate the script with a non-zero status upon encountering errors.\n\n## **Log Generation**\n\n- Produce a `backup_log.txt` in the destination path.\n- Ensure the log is clear and structured, following this example:\n\n---\n\n**Backup Log Report**\n\n- **Date:** `2024-02-29`\n- **Time:** `14:00:00 UTC`\n\n**Machine Information:**\n\n- **Operating System:** `Linux server 5.4.0-42-generic #46-Ubuntu SMP Fri Jul 10 00:24:02 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux`\n\n**Backup Details:**\n\n- **Source Path:** `/home/user/data`\n- **Destination Path:** `/mnt/backup/2024-02-29_data_backup.zip`\n- **Compression Level:** `9`\n- **Files Backed Up:** `1,250`\n- **Directories Backed Up:** `75`\n\n**Backup Summary:**\n\n- **Start Time:** `14:00:00 UTC`\n- **End Time:** `14:05:30 UTC`\n- **Total Duration:** `5 minutes 30 seconds`\n\n---\n\n## **Testing and Execution**\n\nValidate your script using the `need_backup` folder supplied for this assignment.\n\n### **Example Command**\n\n```bash\n./backup_script.sh /home/user/documents /home/user/backup -c 9\n```\n\n### **Expected Outcome**\n\n```text\nBackup of /home/user/documents completed successfully.\nSaved to /home/user/backup/2024-02-29_documents.zip\n```\n\n# **2\u003csup\u003end\u003c/sup\u003e Part: `algebra` Namespace**\n\nThis part is designed to immerse you in the world of linear algebra through programming. You will create a fully functional algebra namespace in C++ that encompasses a variety of matrix operations. From initializing matrices to performing complex operations like multiplication and finding inverses, this assignment will hone your programming skills and teach you some of the features of `C++20`.\n\n## Objective\n\nCreate a namespace with the implementation of all the below functions. be very carefull with all the pitfalls we gave you for each function, you have to check every condition and throw an error anywhere needed.\n\n## `create_matrix`\n\n### Required Types\n\nFirst, make sure the following types are defined within your `algebra` namespace:\n\n```cpp\n// Matrix data structure\ntemplate\u003ctypename T\u003e\nusing MATRIX = std::vector\u003cstd::vector\u003cT\u003e\u003e;\n\n// Matrix initialization types\nenum class MatrixType { Zeros, Ones, Identity, Random };\n```\n\n### Function Prototype\n\n```cpp\n// Function template for matrix initialization\ntemplate\u003ctypename T\u003e\nMATRIX\u003cT\u003e create_matrix(std::size_t rows, std::size_t columns, std::optional\u003cMatrixType\u003e type = MatrixType::Zeros,\n                        std::optional\u003cT\u003e lowerBound = std::nullopt, std::optional\u003cT\u003e upperBound = std::nullopt);\n```\n\n### Description\n\nThis function initializes a matrix of dimensions `rows x columns` with values depending on the specified `MatrixType`. The optional parameters `lowerBound` and `upperBound` are used for random initialization.\n\n- **Zero**: Initializes all elements to 0.\n- **Ones**: Initializes all elements to 1.\n- **Identity**: Creates an identity matrix (1s on the diagonal, 0s elsewhere). **Only works for square matrices**.\n- **Random**: Fills the matrix with random values within the range `[lowerBound, upperBound]`.\n\n### Pitfalls\n\n- **Dimension Mismatch**: For `MatrixType::Identity`, ensure `rows == columns`. An identity matrix must be square.\n- **Random Range**: When `MatrixType::Random` is chosen, both `lowerBound` and `upperBound` must be specified. Ensure `lowerBound \u003c upperBound`. You are also **only** allowed to use `random` library for generating your random numbers.\n\n### Example Usage\n\n```cpp\n// Create a 5x5 zero matrix of integers\nalgebra::MATRIX\u003cint\u003e zerosMatrix = algebra::create_matrix\u003cint\u003e(5, 5);\n\n// Create a 2x2 ones matrix of integers\nalgebra::MATRIX\u003cint\u003e onesMatrix = algebra::create_matrix\u003cint\u003e(2, 2, algebra::MatrixType::Ones);\n\n// Create a 3x3 identity matrix of doubles\nalgebra::MATRIX\u003cint\u003e identityMatrix = algebra::create_matrix\u003cint\u003e(3, 3, algebra::MatrixType::Identity);\n\n// Create a 4x4 matrix of random floats within [0.0, 1.0]\nalgebra::MATRIX\u003cdouble\u003e randomMatrix = algebra::create_matrix\u003cdouble\u003e(4, 4, algebra::MatrixType::Random, 0.0, 10.0);\n```\n\n## `display`\n\n### Function Prototype:\n\n```cpp\ntemplate\u003ctypename T\u003e\nvoid display(const MATRIX\u003cT\u003e\u0026 matrix);\n```\n\n### Description:\n\nThis function is designed to output the contents of a matrix in a formatted manner. It iterates through the matrix and prints each element, ensuring that the display is both aesthetically pleasing and informative. The function strictly uses the `\u003cformat\u003e` library for formatting output, catering to requirements such as fixed width and precision for each element, thus maintaining uniformity and readability.\n\n### Pitfalls:\n\n- **Formatting Consistency**: Ensure that all numbers are displayed with a maximum width of 7 characters. This requires handling both large numbers and those with many decimal places carefully. Improper handling may lead to misaligned rows or columns, which we don not want.\n- **Library Restrictions**: Students are restricted to using only the `\u003cformat\u003e` library for formatting.\n\n### Example Usage:\n\nGiven a matrix `mat`:\n\n```cpp\nalgebra::MATRIX\u003cint\u003e mat = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};\nalgebra::display(mat);\n```\n\nThe expected output should be neatly formatted as follows:\n\n```text\n|   1   |   2   |   3   |\n|   4   |   5   |   6   |\n|   7   |   8   |   9   |\n```\n\n## `sum_sub`\n\n### Function Prototype:\n\n```cpp\ntemplate\u003ctypename T\u003e\nMATRIX\u003cT\u003e sum_sub(const MATRIX\u003cT\u003e\u0026 matrixA, const MATRIX\u003cT\u003e\u0026 matrixB, std::optional\u003cstd::string\u003e operation = \"sum\");\n```\n\n### Description:\n\nThis function performs either the summation or subtraction of two matrices, depending on the specified operation. By default, the function adds the corresponding elements of the input matrices (`matrixA` and `matrixB`). If the `operation` parameter is explicitly set to `\"sub\"`, it subtracts `matrixB` from `matrixA`.\n\n### Pitfalls:\n\n- **Dimension Mismatch**: Ensure that both matrices have the same dimensions. Throw an error otherwise.\n- **Operation Parameter**: The operation parameter accepts only two values: `\"sum\"` and `\"sub\"`. Any other value will default to summation.\n\n### Example Usage:\n\nSummation of two matrices:\n\n```cpp\nalgebra::MATRIX\u003cint\u003e matrixA = {{1, 2, 3}, {4, 5, 6}};\nalgebra::MATRIX\u003cint\u003e matrixB = {{6, 5, 4}, {3, 2, 1}};\nalgebra::MATRIX\u003cint\u003e resultSum = algebra::sum_sub(matrixA, matrixB); // Default operation is \"sum\"\n\n/* Expected Matrix\n|  7  |  7  |  7  |\n|  7  |  7  |  7  |\n*/\n```\n\nSubtraction of two matrices:\n\n```cpp\nalgebra::MATRIX\u003cint\u003e matrixA = {{10, 20, 30}, {40, 50, 60}};\nalgebra::MATRIX\u003cint\u003e matrixB = {{1, 2, 3}, {4, 5, 6}};\nalgebra::MATRIX\u003cint\u003e resultSub = algebra::sum_sub(matrixA, matrixB, \"sub\");\n\n/* Expected Matrix\n|  9  | 18  | 27  |\n| 36  | 45  | 54  |\n*/\n```\n\n## `multiply`\n\n### Function Prototype:\n\nFor scalar multiplication:\n\n```cpp\ntemplate\u003ctypename T\u003e\nMATRIX\u003cT\u003e multiply(const MATRIX\u003cT\u003e\u0026 matrix, const T scalar);\n```\n\nFor matrix multiplication:\n\n```cpp\ntemplate\u003ctypename T\u003e\nMATRIX\u003cT\u003e multiply(const MATRIX\u003cT\u003e\u0026 matrixA, const MATRIX\u003cT\u003e\u0026 matrixB);\n```\n\n### Description:\n\n1. **Scalar Multiplication**: Multiplies each element of a given matrix by a scalar value. This operation enhances or reduces the magnitude of matrix elements uniformly, depending on the scalar value.\n\n2. **Matrix Multiplication**: Computes the product of two matrices by performing the dot product of rows and columns. The operation is defined for two matrices `A` and `B` where the number of columns in `A` matches the number of rows in `B`. The resulting matrix will have dimensions that match the number of rows in `A` and the number of columns in `B`.\n\n### Pitfalls:\n\n- **Dimension Mismatch**: For matrix multiplication, it's crucial that the number of columns in `matrixA` matches the number of rows in `matrixB`. Failure to meet this condition must throw an error.\n\n### Example Usage:\n\nScalar Multiplication:\n\n```cpp\nalgebra::MATRIX\u003cint\u003e mat = {{1, 2}, {3, 4}};\nint scalar = 3;\nalgebra::MATRIX\u003cint\u003e scaledMatrix = algebra::multiply(mat, scalar);\n\n/* Expected Matrix\n|  3  |  6  |\n|  9  | 12  |\n*/\n```\n\nMatrix Multiplication:\n\n```cpp\nalgebra::MATRIX\u003cint\u003e matrixA = {{1, 2, 3}, {4, 5, 6}};\nalgebra::MATRIX\u003cint\u003e matrixB = {{7, 8}, {9, 10}, {11, 12}};\nalgebra::MATRIX\u003cint\u003e productMatrix = algebra::multiply(matrixA, matrixB);\n\n/* Expected Matrix\n|  58  |  64  |\n| 139  | 154  |\n*/\n```\n\n## `hadamard_product`\n\n### Function Prototype:\n\n```cpp\ntemplate\u003ctypename T\u003e\nMATRIX\u003cT\u003e hadamard_product(const MATRIX\u003cT\u003e\u0026 matrixA, const MATRIX\u003cT\u003e\u0026 matrixB);\n```\n\n### Description:\n\nThis function computes the Hadamard Product (also known as the element-wise product) of two matrices of the same dimensions. The Hadamard Product is obtained by multiplying corresponding elements in the two matrices. The result is a new matrix where each element `C[i][j]` is the product of elements `A[i][j]` and `B[i][j]` from the input matrices.\n\n### Pitfalls:\n\n- **Dimension Mismatch**: The matrices `matrixA` and `matrixB` must be of the same size. Attempting to compute the Hadamard Product of matrices with differing dimensions must result in an error.\n\n### Example Usage:\n\nGiven two matrices `matA` and `matB`:\n\n```cpp\nalgebra::MATRIX\u003cint\u003e matA = {{1, 2, 3}, {4, 5, 6}};\nalgebra::MATRIX\u003cint\u003e matB = {{7, 8, 9}, {10, 11, 12}};\nalgebra::MATRIX\u003cint\u003e result = algebra::hadamard_product(matA, matB);\n\n/* Expected Matrix\n|  7  | 16  | 27  |\n| 40  | 55  | 72  |\n*/\n```\n\n## `transpose`\n\n### Function Prototype:\n\n```cpp\ntemplate\u003ctypename T\u003e\nMATRIX\u003cT\u003e transpose(const MATRIX\u003cT\u003e\u0026 matrix);\n```\n\n### Description:\n\nThis function returns the transpose of a given matrix. The transpose of a matrix is obtained by flipping the matrix over its diagonal, thus turning its rows into columns and vice versa. This operation does not alter the original matrix but produces a new matrix where the element at position `[i][j]` in the original matrix is moved to position `[j][i]` in the transposed matrix.\n\n### Pitfalls:\n\n- **Empty Matrix**: If the input matrix is empty, the function should gracefully handle this case and return an empty matrix as the transpose.\n- **Non-Square Matrices**: The function should correctly handle non-square matrices (where the number of rows does not equal the number of columns). The dimensions of the transposed matrix will be different from the original matrix in such cases.\n- **Memory Usage**: Transposing a large matrix may require significant memory for the new matrix, especially if the original matrix is large. Consider the memory implications of your implementation.\n\n### Example Usage:\n\nGiven a matrix `mat`:\n\n```cpp\nalgebra::MATRIX\u003cint\u003e mat = {{1, 2, 3}, {4, 5, 6}};\nalgebra::MATRIX\u003cint\u003e result = transpose(mat);\n\n/* Expected Matrix\n|  1  |  4  |\n|  2  |  5  |\n|  3  |  6  |\n*/\n```\n\n## `trace`\n\n### Function Prototype:\n\n```cpp\ntemplate\u003ctypename T\u003e\nT trace(const MATRIX\u003cT\u003e\u0026 matrix);\n```\n\n### Description:\n\nThis function calculates the trace of a given square matrix. The trace of a matrix is defined as the sum of the elements on the main diagonal (from the top left to the bottom right). It is a concept from linear algebra that **applies only to square matrices** and provides a quick, useful measure of a matrix's properties, including its eigenvalues' sum.\n\n### Pitfalls:\n\n- **Square Matrix Requirement**: The trace can only be calculated for square matrices. If the input matrix is not square your program must throw an error.\n\n### Example Usage:\n\nGiven a square matrix `mat`:\n\n```cpp\nalgebra::MATRIX\u003cint\u003e mat = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};\nint tr = algebra::trace(mat);\n\n/* Expected Result\ntr = 1 + 5 + 9 = 15\n*/\n```\n\n## `determinant`\n\n### Function Prototype:\n\n```cpp\ntemplate\u003ctypename T\u003e\ndouble determinant(const MATRIX\u003cT\u003e\u0026 matrix);\n```\n\n### Description:\n\nThis function calculates the determinant of a given square matrix. The determinant is a scalar value that provides important information about the matrix, such as whether it is invertible (a non-zero determinant) or singular (a determinant of zero).\n\n### Pitfalls:\n\n- **Square Matrix Requirement**: This function can only be applied to **square matrices** (matrices with equal number of rows and columns). Attempting to calculate the determinant of a non-square matrix must throw an error.\n- **Performance**: Calculating the determinant of large matrices can be computationally expensive, especially using recursive methods. Consider the implications of this for very large matrices.\n- **Numerical Stability**: For matrices with elements of floating-point types, the calculation of the determinant can suffer from numerical instability, leading to inaccurate results due to the limitations of floating-point arithmetic.\n\n### Example Usage:\n\nGiven a square matrix `mat`:\n\n```cpp\nalgebra::MATRIX\u003cdouble\u003e mat = {{4, 3}, {6, 3}};\ndouble det = algebra::determinant(mat);\n\n/* Expected Result\ndet = (4*3) - (3*6) = 12 - 18 = -6.0\n*/\n```\n\n## `inverse`\n\n### Function Prototype:\n\n```cpp\ntemplate\u003ctypename T\u003e\nMATRIX\u003cdouble\u003e inverse(const MATRIX\u003cT\u003e\u0026 matrix);\n```\n\n### Description:\n\nThis function calculates the inverse of a given square matrix, if it exists. The inverse of a matrix `A` is another matrix `A^-1` such that the product of `A` and `A^-1` yields the identity matrix. The calculation of the inverse is typically based on the method of Gaussian elimination or finding the adjugate and determinant of the matrix. It is important to note that not all matrices have an inverse; a matrix must be square and have a non-zero determinant to be invertible.\n\n### Pitfalls:\n\n- **Square Matrix Requirement**: Only square matrices (matrices with the same number of rows and columns) can have inverses. The function must check for this condition and handle non-square matrices with throwing error.\n- **Determinant Check**: Before attempting to calculate the inverse, it's crucial to check that the determinant of the matrix is not zero. A zero determinant means the matrix is singular and does not have an inverse. if this happens, error is what you need to throw.\n- **Numerical Stability**: For matrices with floating-point elements, the process of calculating the inverse may be subject to numerical instability, leading to inaccuracies. It's important to implement the algorithm carefully to minimize errors.\n\n### Example Usage:\n\nGiven a square matrix `mat`:\n\n```cpp\nalgebra::MATRIX\u003cdouble\u003e mat = {{4, 7}, {2, 6}};\nalgebra::MATRIX\u003cdouble\u003e invMat = algebra::inverse(mat);\n\n/* Expected Matrix\n|  3/5  | -7/10 |\n| -1/5  |  2/5  |\n*/\n```\n\n## **Final Step: How To Test Your Program**\n\nIf you want to debug your code, set the `if` statement to `true`. This will allow you to place your debugging code in the designated section. Once you're done with the debugging process, remember to set the `if` statement back to `false` to test your program using the provided `unit-test.cpp`.\n\nFurthermore, whatever code you write should be implemented in the `algebra.cpp` and `algebra.h` files. Please refrain from making any changes to other files in the project.\n\n```cpp\n#include \u003ciostream\u003e\n#include \u003cgtest/gtest.h\u003e\n#include \"algebra.h\"\n\nint main(int argc, char **argv)\n{\n    if (true) // Set to false to run unit-tests\n    {\n        // Debug section: Place your debugging code here\n    }\n    else\n    {\n        ::testing::InitGoogleTest(\u0026argc, argv);\n        std::cout \u003c\u003c \"RUNNING TESTS ...\" \u003c\u003c std::endl;\n        int ret{RUN_ALL_TESTS()};\n        if (!ret)\n            std::cout \u003c\u003c \"\u003c\u003c\u003cSUCCESS\u003e\u003e\u003e\" \u003c\u003c std::endl;\n        else\n            std::cout \u003c\u003c \"FAILED\" \u003c\u003c std::endl;\n    }\n    return 0;\n}\n```\n\n\u003cp align=\"center\"\u003e\n  \u003cimg src=\"./Resource/Say_Hello_To_Other_Errors.webp\" alt=\"Say Hello To Other Errors\" style=\"width: 40%;\"\u003e\n\u003c/p\u003e\n\n**Best Regards, [Hamidi](https://github.com/smhamidi)**\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcourseworks%2Faut_ap_2024_spring_hw1","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcourseworks%2Faut_ap_2024_spring_hw1","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcourseworks%2Faut_ap_2024_spring_hw1/lists"}