donnpie · July 16, 2025 13:16
diff --git a/.gitignore b/.gitignore
 /.ipynb_checkpoints
 /cheatvenv
diff --git a/1. Where to find what.md b/1. Where to find what.md
diff --git a/3. Steps to create a full stack app.md b/3. Steps to create a full stack app.md
diff --git a/README.md template.md b/README.md template.md
diff --git a/About Design Specifications.md b/About Design Specifications.md
diff --git a/ChatGPT prompts cheatsheet.md b/ChatGPT prompts cheatsheet.md
diff --git a/Deployment cicd cheatsheet.md b/Deployment cicd cheatsheet.md
diff --git a/Dev container cheatsheet.md b/Dev container cheatsheet.md
diff --git a/Docker cheatsheet.md b/Docker cheatsheet.md
diff --git a/Email validation with JWT.md b/Email validation with JWT.md
diff --git a/File naming conventions.md b/File naming conventions.md
diff --git a/Git and GitHub cheatsheet.md b/Git and GitHub cheatsheet.md
diff --git a/GitHub Actions cheatsheet.md b/GitHub Actions cheatsheet.md
diff --git a/Google tracking code cheatsheet.md b/Google tracking code cheatsheet.md
diff --git a/JS TS cheatsheet.md b/JS TS cheatsheet.md
diff --git a/Markdown cheatsheet.md b/Markdown cheatsheet.md
diff --git a/Mermaid cheat sheet.md b/Mermaid cheat sheet.md
diff --git a/Mongo cheatsheet.md b/Mongo cheatsheet.md
diff --git a/Pandas cheatsheet.ipynb b/Pandas cheatsheet.ipynb
diff --git a/PostgresQL cheatsheet.md b/PostgresQL cheatsheet.md
diff --git a/Python cheatsheet.ipynb b/Python cheatsheet.ipynb
 {
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# General info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Created by Donn Pienaar\n",
    "#2019-01-08\n",
    "#Python 3.7\n",
    "#This file is meant to serve as a quick look-up guide for the most common \n",
    "#data related functions in Python\n",
    "\n",
    "#Comments: #This is a comment\n",
    "\n",
    "#The shortcut for run (Jupyter Notebook) is Shift + Enter\n",
    "\n",
    "#type casting:\n",
    "#float(2)\n",
    "\n",
    "#Bool values: First letter must be capital: True, False\n",
    "\n",
    "#float division: 5/6 = 0.8333333333333334\n",
    "#whole number division: 5//6 = 0\n",
    "\n",
    "#Incrementing:\n",
    "#x = 0\n",
    "#x += 1\n",
    "#x\n",
    "\n",
    "#Print to screen: print(\"Hello\")\n",
    "\n",
    "#Print a number to screen using %:\n",
    "a = 1\n",
    "#print('Number is: %d' % (a))\n",
    "\n",
    "#Print a string to screen using %:\n",
    "#mystr = 'abc'\n",
    "#print('String is: %s' % (mystr))\n",
    "\n",
    "#Numerical constants:\n",
    "import math as m\n",
    "#m.pi\n",
    "#m.e\n",
    "#Pi and e are also declared in the numpy library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#string methods: upper, lower, replace, find\n",
    "\n",
    "#split string on a delimiter:\n",
    "#string = \"This is a sentence. This is another sentence.\"\n",
    "#list = string.split('.')\n",
    "#print(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data structures:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tupples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Tupples\n",
    "#represented with parentheses ()\n",
    "#immutable (cannot be changed)\n",
    "#can be accessed by index: myTupple[0]\n",
    "#syntax example: myTupple = (1, 9)\n",
    "#can be added together (adding works like appending):\n",
    "#t1 = (1, 2)\n",
    "#t2 = (3, 4)\n",
    "#print(t1 + t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Lists\n",
    "#represented with brackets []\n",
    "#mutable (can be changed)\n",
    "#can be accessed by index: myList[0]\n",
    "#syntax example: myList = [1, 9]\n",
    "#can be added together (adding works like appending):\n",
    "#l1 = [1, 2]\n",
    "#l2 = [3, 4]\n",
    "#print(l1 + l2)\n",
    "\n",
    "#append creates 1 new element in the list:\n",
    "#l1.append(['Pop', 1])\n",
    "#print(l1)\n",
    "\n",
    "#extend creates 2 new elements in the list:\n",
    "#l1.extend(['Pop', 1])\n",
    "#print(l1)\n",
    "\n",
    "#delete item from list:\n",
    "#l1 = [1, 2]\n",
    "#del(l1[0])\n",
    "#print(l1)\n",
    "\n",
    "#Alias (two variables pointing to the same data)\n",
    "#A = [1, 2]\n",
    "#B = A #B and A now point to the same data\n",
    "#B[0] = 5 #changing a value in B also changes it in A\n",
    "#print(A)\n",
    "#print(A == B)\n",
    "#print(A is B)\n",
    "\n",
    "#Cloning (make seperate copy of data)\n",
    "#A = [1, 2]\n",
    "#B = A[:] #make a clone using a slice\n",
    "#B[0] = 5 #changing a value in B also changes it in A\n",
    "#print(A)\n",
    "#print(A == B)\n",
    "#print(A is B)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n",
      "{3}\n",
      "{1, 2, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "#Sets\n",
    "#represented with braces {}\n",
    "#sets can only contain unique values\n",
    "#Duplicates are automatically dropped\n",
    "\n",
    "#Convert a list to a set:\n",
    "#list1 = [1, 2, 3, 3]\n",
    "#set1 = set(list1)\n",
    "#set1\n",
    "\n",
    "#Add to a set:\n",
    "#set1 = {1, 2, 3}\n",
    "#set1.add(3) #does nothing because 3 is already in the set\n",
    "#print(set1)\n",
    "#set1.add(4) #adds 4 to the set\n",
    "#print(set1)\n",
    "\n",
    "#Remove element from a set:\n",
    "#set1 = {1, 2, 3}\n",
    "#set1.remove(3) #removes 3\n",
    "#print(set1)\n",
    "#set1.remove(3) #This produces an error because 3 is not in the set\n",
    "#print(set1)\n",
    "\n",
    "#Check if element is in a set:\n",
    "#set1 = {1, 2, 3}\n",
    "#print(3 in set1) #returns true\n",
    "#print(4 in set1) #returns false\n",
    "\n",
    "#set intersection, union, subset:\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {3, 4, 5}\n",
    "set3 = set1.intersection(set2)\n",
    "set1.union(set2)\n",
    "set3.issubset(set1) #set3 is a subset of set1\n",
    "print(set1.union(set2))\n",
    "print(set1.intersection(set2))\n",
    "print(set1.union(set2)-set1.intersection(set2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#A dictionary is a key-value pair data structure\n",
    "#represented with braces {}\n",
    "dict = {'key1': 'value1',\n",
    "       'key2': 'value2',\n",
    "        'key3': 'value3'\n",
    "}\n",
    "\n",
    "#To get a list of all keys in a dictionary:\n",
    "k = dict.keys() #returns type dict_keys\n",
    "type(k)\n",
    "\n",
    "#To get a list of all keys in a dictionary:\n",
    "v = dict.values() #returns type dict_values\n",
    "type(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "The\n",
      "sheep\n",
      "is\n",
      "black\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "#for loop\n",
    "for i in range (0, 3): #Remember the :\n",
    "    print(i)\n",
    "    \n",
    "#for each loop\n",
    "list = ['The', 'sheep', 'is', 'black']\n",
    "for i in list:\n",
    "    print(i)\n",
    "    \n",
    "#while loop\n",
    "i = 0\n",
    "while i < 6:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditionals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#switch case\n",
    "#see https://jaxenter.com/implement-switch-case-statement-python-138315.html\n",
    "#def switch_funct(arg):\n",
    "#    switcher = {1: \"jan\",\n",
    "#               2: \"feb\",\n",
    "#               3: \"mar\"}\n",
    "#    return switcher.get(arg, \"invalid\")\n",
    "#m = switch_funct(1)\n",
    "#m\n",
    "                       \n",
    "#if statement\n",
    "#x = 5\n",
    "#if x < 3:\n",
    "#    print(\"Condition is True\")\n",
    "#print(\"Condition is False\") #Note the absense of the else statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic file I/O"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0123450\\n', '1\\n', '2\\n', '3\\n', '4\\n', '5\\n', '012345']\n"
     ]
    }
   ],
   "source": [
    "#See https://www.pythonforbeginners.com/files/reading-and-writing-files-in-python\n",
    "\n",
    "#Syntax for opening a file:\n",
    "#file1 = open('SampleTextFile.txt', 'r+') #where:\n",
    "                                #SampleTextFile.txt is the filename and path\n",
    "                                # 'w' is the mode (write mode) Existing files with the same name will be erased.\n",
    "                                #There is also 'r' (read) and 'a' (append)\n",
    "                                # adding a + after w, r or a will create the file if it does not exist\n",
    "#Getting the file name:\n",
    "#file1.name\n",
    "\n",
    "#getting the file mode:\n",
    "#file1.mode\n",
    "\n",
    "#To write to a file:\n",
    "#for i in range (0, 6):\n",
    "#    file1.write(str(i) + '\\n')\n",
    "\n",
    "#To read text from a file:\n",
    "#content1 = file1.read() #reads all the file contents into a single str variable\n",
    "#print(content1)\n",
    "\n",
    "#To read from a file using a loop:\n",
    "with open('SampleTextFile.txt', 'r+') as file2:\n",
    "    content2 = file2.readlines()\n",
    "    print(content2)\n",
    "    #file is automatically closed after while loop is finished, so no need to use close method\n",
    "\n",
    "#Remember to close the file after use like so:\n",
    "#file1.close()\n",
    "\n",
    "#Example from Tutorialspoint.com\n",
    "# Open a file\n",
    "#fo = open(\"SampleTextFile.txt\", \"r+\")\n",
    "#print(\"Name of the file: \", fo.name)\n",
    "\n",
    "# Assuming file has following 5 lines\n",
    "# This is 1st line\n",
    "# This is 2nd line\n",
    "# This is 3rd line\n",
    "# This is 4th line\n",
    "# This is 5th line\n",
    "\n",
    "#line = fo.readlines()\n",
    "#print(\"Read Line: %s\" % (line))\n",
    "\n",
    "#line = fo.readlines(2)\n",
    "#print (\"Read Line: %s\" % (line))\n",
    "\n",
    "# Close opend file\n",
    "#fo.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas general info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#To use pandas you have to import the library:\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "csv_path = 'CSV demo.txt' #specify the path and filename\n",
    "#df = pd.read_csv(csv_path)\n",
    "\n",
    "#To show the first few lines of the dataframe:\n",
    "#df.head()\n",
    "\n",
    "#To read from an excel file:\n",
    "xl_path = 'Excel demo.xlsx' #specify the path and filename\n",
    "df = pd.read_excel(xl_path)\n",
    "\n",
    "#To show the first few lines of the dataframe:\n",
    "#df.head()\n",
    "\n",
    "#A dataframe can also be created from a dictionary:\n",
    "#dict = {'key1': ['value1', 'value2'],\n",
    "#       'key2': ['value1', 'value2']}\n",
    "#df = pd.DataFrame(dict)\n",
    "#df.head()\n",
    "\n",
    "#To create an extract from a dataframe:\n",
    "#See https://pythonhow.com/accessing-dataframe-columns-rows-and-cells/\n",
    "#df = pd.read_csv(csv_path)\n",
    "#print(df.head())\n",
    "#x = df[[\"Age\", \"Name\"]] #Note the double brackets\n",
    "#syntx for dataframe slicer: df.loc[startrow:endrow, startcolumn:endcolumn]\n",
    "#x.head()\n",
    "\n",
    "#Set an index column:\n",
    "#df2 = df.set_index(\"Name\", drop = False) #set an index column with unique values\n",
    "\n",
    "#Elements in a dataframe can be accessed by row/col:\n",
    "#df = pd.read_csv(csv_path)\n",
    "#df.iloc[0,0]\n",
    "\n",
    "#To overwrite a single cell in a dataframe:\n",
    "#for row in range(row_count): \n",
    "#    new_value = ... #get the new value from somewhere\n",
    "#   df.iat[row, 1] = new_value #Overwrites values in column 2 (column index = 1)\n",
    "\n",
    "#To return unique elements from a dataframe:\n",
    "#df = pd.read_csv(csv_path)\n",
    "#AgeList = df['Age'].unique()\n",
    "\n",
    "#To get descriptive statistics for a dataframe\n",
    "#df = pd.read_csv(csv_path)\n",
    "#df.describe()\n",
    "\n",
    "\n",
    "#To save a dataframe to a csv file\"\n",
    "#df = pd.read_csv(csv_path)\n",
    "#df.to_csv('newCsvFile.txt')\n",
    "#Other functions exist for other data formats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy general info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#To use numpy you have to import the library:\n",
    "import numpy as np\n",
    "\n",
    "#numpy basic info: https://docs.scipy.org/doc/numpy-1.13.0/user/whatisnumpy.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "#Creating a numpy array from a list:\n",
    "x = [0, 1, 2]\n",
    "a = np.array(x)\n",
    "a\n",
    "#elements can be accessed by index in the usual way\n",
    "\n",
    "#Array properties:\n",
    "#print(type(a)) #array type\n",
    "#print(a.dtype) #data type of the elements in the array (must all be of the same type)\n",
    "#print(a.size) #number of elements\n",
    "#print(a.ndim) #number of dimensions\n",
    "#print(a.shape) #number of entries in each dimension\n",
    "\n",
    "\n",
    "#basic algebraic operations:\n",
    "x = [0, 1, 2]\n",
    "y = [3, 4, 5]\n",
    "u = np.array(x)\n",
    "v = np.array(y)\n",
    "#print(u+v) #vector addition\n",
    "#print(u*v) #position wise multiplication\n",
    "#print(np.dot(u, v)) #dot product\n",
    "\n",
    "#basic statistical operations:\n",
    "print(np.average(a)) #find the average. Same for min, max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib general info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#To use matplotlib you have to import the library:\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2d159a4e4a8>]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "x = np.linspace(0, 2*np.pi, 100) #Create 100 evenly spaced values on the interval 0 to 2pi\n",
    "#numpy also has a function called arange that works similar to linspace, but is easier to use\n",
    "#check out the numpy documentation\n",
    "y = np.sin(x) #create y as a function of x\n",
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0., 1., 2., 3., 4., 5., 6., 3., 2., 1.]),\n",
       " array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#To create a histogram:\n",
    "#See Matplotlib Tutorial 3 bar charts and histograms from sentdex on YouTube\n",
    "population = [1, 2,2, 3, 3, 3, 4,4,4,4,5,5,5,5,5,6,6,6,6,6,6, 7,7,7, 8,8, 9]\n",
    "bins = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "%matplotlib inline\n",
    "plt.hist(population, bins, histtype='bar',rwidth=0.8, align='left')\n",
    "#For help on histogram, type help(plt.hist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# To get help in Python\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function hist in module matplotlib.pyplot:\n",
      "\n",
      "hist(x, bins=None, range=None, density=None, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, normed=None, *, data=None, **kwargs)\n",
      "    Plot a histogram.\n",
      "    \n",
      "    Compute and draw the histogram of *x*. The return value is a\n",
      "    tuple (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*,\n",
      "    [*patches0*, *patches1*,...]) if the input contains multiple\n",
      "    data.\n",
      "    \n",
      "    Multiple data can be provided via *x* as a list of datasets\n",
      "    of potentially different length ([*x0*, *x1*, ...]), or as\n",
      "    a 2-D ndarray in which each column is a dataset.  Note that\n",
      "    the ndarray form is transposed relative to the list form.\n",
      "    \n",
      "    Masked arrays are not supported at present.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    x : (n,) array or sequence of (n,) arrays\n",
      "        Input values, this takes either a single array or a sequence of\n",
      "        arrays which are not required to be of the same length.\n",
      "    \n",
      "    bins : int or sequence or str, optional\n",
      "        If an integer is given, ``bins + 1`` bin edges are calculated and\n",
      "        returned, consistent with `numpy.histogram`.\n",
      "    \n",
      "        If `bins` is a sequence, gives bin edges, including left edge of\n",
      "        first bin and right edge of last bin.  In this case, `bins` is\n",
      "        returned unmodified.\n",
      "    \n",
      "        All but the last (righthand-most) bin is half-open.  In other\n",
      "        words, if `bins` is::\n",
      "    \n",
      "            [1, 2, 3, 4]\n",
      "    \n",
      "        then the first bin is ``[1, 2)`` (including 1, but excluding 2) and\n",
      "        the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which\n",
      "        *includes* 4.\n",
      "    \n",
      "        Unequally spaced bins are supported if *bins* is a sequence.\n",
      "    \n",
      "        With Numpy 1.11 or newer, you can alternatively provide a string\n",
      "        describing a binning strategy, such as 'auto', 'sturges', 'fd',\n",
      "        'doane', 'scott', 'rice', 'sturges' or 'sqrt', see\n",
      "        `numpy.histogram`.\n",
      "    \n",
      "        The default is taken from :rc:`hist.bins`.\n",
      "    \n",
      "    range : tuple or None, optional\n",
      "        The lower and upper range of the bins. Lower and upper outliers\n",
      "        are ignored. If not provided, *range* is ``(x.min(), x.max())``.\n",
      "        Range has no effect if *bins* is a sequence.\n",
      "    \n",
      "        If *bins* is a sequence or *range* is specified, autoscaling\n",
      "        is based on the specified bin range instead of the\n",
      "        range of x.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    density : bool, optional\n",
      "        If ``True``, the first element of the return tuple will\n",
      "        be the counts normalized to form a probability density, i.e.,\n",
      "        the area (or integral) under the histogram will sum to 1.\n",
      "        This is achieved by dividing the count by the number of\n",
      "        observations times the bin width and not dividing by the total\n",
      "        number of observations. If *stacked* is also ``True``, the sum of\n",
      "        the histograms is normalized to 1.\n",
      "    \n",
      "        Default is ``None`` for both *normed* and *density*. If either is\n",
      "        set, then that value will be used. If neither are set, then the\n",
      "        args will be treated as ``False``.\n",
      "    \n",
      "        If both *density* and *normed* are set an error is raised.\n",
      "    \n",
      "    weights : (n, ) array_like or None, optional\n",
      "        An array of weights, of the same shape as *x*.  Each value in *x*\n",
      "        only contributes its associated weight towards the bin count\n",
      "        (instead of 1).  If *normed* or *density* is ``True``,\n",
      "        the weights are normalized, so that the integral of the density\n",
      "        over the range remains 1.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    cumulative : bool, optional\n",
      "        If ``True``, then a histogram is computed where each bin gives the\n",
      "        counts in that bin plus all bins for smaller values. The last bin\n",
      "        gives the total number of datapoints. If *normed* or *density*\n",
      "        is also ``True`` then the histogram is normalized such that the\n",
      "        last bin equals 1. If *cumulative* evaluates to less than 0\n",
      "        (e.g., -1), the direction of accumulation is reversed.\n",
      "        In this case, if *normed* and/or *density* is also ``True``, then\n",
      "        the histogram is normalized such that the first bin equals 1.\n",
      "    \n",
      "        Default is ``False``\n",
      "    \n",
      "    bottom : array_like, scalar, or None\n",
      "        Location of the bottom baseline of each bin.  If a scalar,\n",
      "        the base line for each bin is shifted by the same amount.\n",
      "        If an array, each bin is shifted independently and the length\n",
      "        of bottom must match the number of bins.  If None, defaults to 0.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    histtype : {'bar', 'barstacked', 'step',  'stepfilled'}, optional\n",
      "        The type of histogram to draw.\n",
      "    \n",
      "        - 'bar' is a traditional bar-type histogram.  If multiple data\n",
      "          are given the bars are arranged side by side.\n",
      "    \n",
      "        - 'barstacked' is a bar-type histogram where multiple\n",
      "          data are stacked on top of each other.\n",
      "    \n",
      "        - 'step' generates a lineplot that is by default\n",
      "          unfilled.\n",
      "    \n",
      "        - 'stepfilled' generates a lineplot that is by default\n",
      "          filled.\n",
      "    \n",
      "        Default is 'bar'\n",
      "    \n",
      "    align : {'left', 'mid', 'right'}, optional\n",
      "        Controls how the histogram is plotted.\n",
      "    \n",
      "            - 'left': bars are centered on the left bin edges.\n",
      "    \n",
      "            - 'mid': bars are centered between the bin edges.\n",
      "    \n",
      "            - 'right': bars are centered on the right bin edges.\n",
      "    \n",
      "        Default is 'mid'\n",
      "    \n",
      "    orientation : {'horizontal', 'vertical'}, optional\n",
      "        If 'horizontal', `~matplotlib.pyplot.barh` will be used for\n",
      "        bar-type histograms and the *bottom* kwarg will be the left edges.\n",
      "    \n",
      "    rwidth : scalar or None, optional\n",
      "        The relative width of the bars as a fraction of the bin width.  If\n",
      "        ``None``, automatically compute the width.\n",
      "    \n",
      "        Ignored if *histtype* is 'step' or 'stepfilled'.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    log : bool, optional\n",
      "        If ``True``, the histogram axis will be set to a log scale. If\n",
      "        *log* is ``True`` and *x* is a 1D array, empty bins will be\n",
      "        filtered out and only the non-empty ``(n, bins, patches)``\n",
      "        will be returned.\n",
      "    \n",
      "        Default is ``False``\n",
      "    \n",
      "    color : color or array_like of colors or None, optional\n",
      "        Color spec or sequence of color specs, one per dataset.  Default\n",
      "        (``None``) uses the standard line color sequence.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    label : str or None, optional\n",
      "        String, or sequence of strings to match multiple datasets.  Bar\n",
      "        charts yield multiple patches per dataset, but only the first gets\n",
      "        the label, so that the legend command will work as expected.\n",
      "    \n",
      "        default is ``None``\n",
      "    \n",
      "    stacked : bool, optional\n",
      "        If ``True``, multiple data are stacked on top of each other If\n",
      "        ``False`` multiple data are arranged side by side if histtype is\n",
      "        'bar' or on top of each other if histtype is 'step'\n",
      "    \n",
      "        Default is ``False``\n",
      "    \n",
      "    normed : bool, optional\n",
      "        Deprecated; use the density keyword argument instead.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    n : array or list of arrays\n",
      "        The values of the histogram bins. See *normed* or *density*\n",
      "        and *weights* for a description of the possible semantics.\n",
      "        If input *x* is an array, then this is an array of length\n",
      "        *nbins*. If input is a sequence of arrays\n",
      "        ``[data1, data2,..]``, then this is a list of arrays with\n",
      "        the values of the histograms for each of the arrays in the\n",
      "        same order.\n",
      "    \n",
      "    bins : array\n",
      "        The edges of the bins. Length nbins + 1 (nbins left edges and right\n",
      "        edge of last bin).  Always a single array even when multiple data\n",
      "        sets are passed in.\n",
      "    \n",
      "    patches : list or list of lists\n",
      "        Silent list of individual patches used to create the histogram\n",
      "        or list of such list if multiple input datasets.\n",
      "    \n",
      "    Other Parameters\n",
      "    ----------------\n",
      "    **kwargs : `~matplotlib.patches.Patch` properties\n",
      "    \n",
      "    See also\n",
      "    --------\n",
      "    hist2d : 2D histograms\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    .. [Notes section required for data comment. See #10189.]\n",
      "    \n",
      "    .. note::\n",
      "        In addition to the above described arguments, this function can take a\n",
      "        **data** keyword argument. If such a **data** argument is given, the\n",
      "        following arguments are replaced by **data[<arg>]**:\n",
      "    \n",
      "        * All arguments with the following names: 'weights', 'x'.\n",
      "    \n",
      "        Objects passed as **data** must support item access (``data[<arg>]``) and\n",
      "        membership test (``<arg> in data``).\n",
      "\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ArgInfo',\n",
       " 'ArgSpec',\n",
       " 'Arguments',\n",
       " 'Attribute',\n",
       " 'BlockFinder',\n",
       " 'BoundArguments',\n",
       " 'CORO_CLOSED',\n",
       " 'CORO_CREATED',\n",
       " 'CORO_RUNNING',\n",
       " 'CORO_SUSPENDED',\n",
       " 'CO_ASYNC_GENERATOR',\n",
       " 'CO_COROUTINE',\n",
       " 'CO_GENERATOR',\n",
       " 'CO_ITERABLE_COROUTINE',\n",
       " 'CO_NESTED',\n",
       " 'CO_NEWLOCALS',\n",
       " 'CO_NOFREE',\n",
       " 'CO_OPTIMIZED',\n",
       " 'CO_VARARGS',\n",
       " 'CO_VARKEYWORDS',\n",
       " 'ClosureVars',\n",
       " 'EndOfBlock',\n",
       " 'FrameInfo',\n",
       " 'FullArgSpec',\n",
       " 'GEN_CLOSED',\n",
       " 'GEN_CREATED',\n",
       " 'GEN_RUNNING',\n",
       " 'GEN_SUSPENDED',\n",
       " 'OrderedDict',\n",
       " 'Parameter',\n",
       " 'Signature',\n",
       " 'TPFLAGS_IS_ABSTRACT',\n",
       " 'Traceback',\n",
       " '_ClassMethodWrapper',\n",
       " '_KEYWORD_ONLY',\n",
       " '_MethodWrapper',\n",
       " '_NonUserDefinedCallables',\n",
       " '_PARAM_NAME_MAPPING',\n",
       " '_POSITIONAL_ONLY',\n",
       " '_POSITIONAL_OR_KEYWORD',\n",
       " '_ParameterKind',\n",
       " '_VAR_KEYWORD',\n",
       " '_VAR_POSITIONAL',\n",
       " '_WrapperDescriptor',\n",
       " '__author__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_check_class',\n",
       " '_check_instance',\n",
       " '_empty',\n",
       " '_filesbymodname',\n",
       " '_findclass',\n",
       " '_finddoc',\n",
       " '_get_paramkind_descr',\n",
       " '_getfullargs',\n",
       " '_is_type',\n",
       " '_main',\n",
       " '_missing_arguments',\n",
       " '_sentinel',\n",
       " '_shadowed_dict',\n",
       " '_signature_bound_method',\n",
       " '_signature_from_builtin',\n",
       " '_signature_from_callable',\n",
       " '_signature_from_function',\n",
       " '_signature_fromstr',\n",
       " '_signature_get_bound_param',\n",
       " '_signature_get_partial',\n",
       " '_signature_get_user_defined_method',\n",
       " '_signature_is_builtin',\n",
       " '_signature_is_functionlike',\n",
       " '_signature_strip_non_python_syntax',\n",
       " '_static_getmro',\n",
       " '_too_many',\n",
       " '_void',\n",
       " 'abc',\n",
       " 'attrgetter',\n",
       " 'builtins',\n",
       " 'classify_class_attrs',\n",
       " 'cleandoc',\n",
       " 'collections',\n",
       " 'currentframe',\n",
       " 'dis',\n",
       " 'enum',\n",
       " 'findsource',\n",
       " 'formatannotation',\n",
       " 'formatannotationrelativeto',\n",
       " 'formatargspec',\n",
       " 'formatargvalues',\n",
       " 'functools',\n",
       " 'getabsfile',\n",
       " 'getargs',\n",
       " 'getargspec',\n",
       " 'getargvalues',\n",
       " 'getattr_static',\n",
       " 'getblock',\n",
       " 'getcallargs',\n",
       " 'getclasstree',\n",
       " 'getclosurevars',\n",
       " 'getcomments',\n",
       " 'getcoroutinelocals',\n",
       " 'getcoroutinestate',\n",
       " 'getdoc',\n",
       " 'getfile',\n",
       " 'getframeinfo',\n",
       " 'getfullargspec',\n",
       " 'getgeneratorlocals',\n",
       " 'getgeneratorstate',\n",
       " 'getinnerframes',\n",
       " 'getlineno',\n",
       " 'getmembers',\n",
       " 'getmodule',\n",
       " 'getmodulename',\n",
       " 'getmro',\n",
       " 'getouterframes',\n",
       " 'getsource',\n",
       " 'getsourcefile',\n",
       " 'getsourcelines',\n",
       " 'importlib',\n",
       " 'indentsize',\n",
       " 'isabstract',\n",
       " 'isasyncgen',\n",
       " 'isasyncgenfunction',\n",
       " 'isawaitable',\n",
       " 'isbuiltin',\n",
       " 'isclass',\n",
       " 'iscode',\n",
       " 'iscoroutine',\n",
       " 'iscoroutinefunction',\n",
       " 'isdatadescriptor',\n",
       " 'isframe',\n",
       " 'isfunction',\n",
       " 'isgenerator',\n",
       " 'isgeneratorfunction',\n",
       " 'isgetsetdescriptor',\n",
       " 'ismemberdescriptor',\n",
       " 'ismethod',\n",
       " 'ismethoddescriptor',\n",
       " 'ismodule',\n",
       " 'isroutine',\n",
       " 'istraceback',\n",
       " 'itertools',\n",
       " 'k',\n",
       " 'linecache',\n",
       " 'mod_dict',\n",
       " 'modulesbyfile',\n",
       " 'namedtuple',\n",
       " 'os',\n",
       " 're',\n",
       " 'signature',\n",
       " 'stack',\n",
       " 'sys',\n",
       " 'token',\n",
       " 'tokenize',\n",
       " 'trace',\n",
       " 'types',\n",
       " 'unwrap',\n",
       " 'v',\n",
       " 'walktree',\n",
       " 'warnings']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#How to print a list of available methods for an object:\n",
    "#print(dir(y))\n",
    "#Can also call dir on a library:\n",
    "#import numpy as np\n",
    "#print(dir(np))\n",
    "#To get help on a specific method of a class:\n",
    "#help(np.setxor1d) #prints the doc string from the method\n",
    "#import inspect\n",
    "#dir(inspect) #The getsource() method from the inspect library can be used to read the source code of a method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
 }
diff --git a/RTL cheatsheet.md b/RTL cheatsheet.md
diff --git a/RTL_get_vs_find_vs_query.png b/RTL_get_vs_find_vs_query.png
diff --git a/create_project_folder.sh b/create_project_folder.sh
diff --git a/neo4j cheatsheet.md b/neo4j cheatsheet.md
diff --git a/networkExplanation.md b/networkExplanation.md
diff --git a/nginx cheatsheet.md b/nginx cheatsheet.md
diff --git a/npm cheatsheet.md b/npm cheatsheet.md
diff --git a/practice.html b/practice.html
diff --git a/pytest.monkeypatch.md b/pytest.monkeypatch.md
diff --git a/Railway.app cheatsheet.md b/Railway.app cheatsheet.md
diff --git a/React cheatsheet.md b/React cheatsheet.md
diff --git a/React router dom v6.4 cheatsheet.md b/React router dom v6.4 cheatsheet.md
diff --git a/RTL_method_priority.png b/RTL_method_priority.png
diff --git a/sympy cheatsheet.ipynb b/sympy cheatsheet.ipynb
diff --git a/sympy script.py b/sympy script.py
diff --git a/workspace cheatsheet.md b/workspace cheatsheet.md
diff --git a/workspaceTemplate.json b/workspaceTemplate.json
diff --git a/YAML cheatsheet.yml b/YAML cheatsheet.yml
Doc name	Desription	Location	Format
[[Deployment cicd cheatsheet\|Deployment CI/CD cheatsheet]]	General notes on how to deploy. Linode Linux Ubuntu VM deployment	C:\Users\donnp\source\repos	Markdown
[[Dev container cheatsheet]]	How to set up a dev container for your project	C:\Users\donnp\source\repos	Markdown
[[Email validation with JWT]]	Walkthrough of how to create a registration and login system with email verification	C:\Users\donnp\source\repos	Markdown
[[Git cheatsheet]]	How to work with git and GitHub	C:\Users\donnp\source\repos	Markdown
[[HTML cheatsheet]]	Folder containing various HTML code examples	OneDrive/Programming/CheatSheets	HTML, Markdown
[[Mermaid cheatsheet]]	How to use Mermaid to create various types of diagrams in Markdown	C:\Users\donnp\source\repos	Markdown
[[Mongo cheatsheet]]	How to work with Mongo in javascript	C:\Users\donnp\source\repos	Markdown
[[neoj4 cheatsheet]]	how to work with neoj4	C:\Users\donnp\source\repos	Markdown
[[npm cheatsheet]]	How to work with Node Package Manager	C:\Users\donnp\source\repos	Markdown
[[Pandas cheatsheet]]	How to work with Python Pandas	C:\Users\donnp\source\repos	Jupyter notebook
[[Python cheatsheet]]	Basic python syntax	C:\Users\donnp\source\repos	Jupyter notebook
[[Railway.app cheatsheet]]	How to deploy an app on Railway.app	C:\Users\donnp\source\repos	Markdown
[[React cheetsheet]]	Basic React and JSX syntax (javascript)	C:\Users\donnp\source\repos	Markdown
[[React Router Cheatsheet]]	How to use React Router	C:\Users\donnp\source\repos	Markdown
README.md template	Generic template for creating a readme doc	C:\Users\donnp\source\repos	Markdown
[[RTL cheatsheet]]	React Testing Library	C:\Users\donnp\source\repos	Markdown
[[Scaling calcs for css clamps]]	Calculate values for css clamps, convert pixels to rem	OneDrive/Programming/CheatSheets	Excel
[[Steps to create full stack app]]	How to create a registration and login system with a React TypeScript frontend, Node/Express backend, and PostgreSQL database	C:\Users\donnp\source\repos	Markdown
[[UML cheatsheet]]	Unified Modeling Language	OneDrive/Programming/CheatSheets	PDF
Repo name	Description	Start date	Languages, libraries, technologies	Noteworthy bits
PersonalWebsite	My personal website where I can do just what I want	yyyy-mm-dd	-	-
CaseStudyBotWithVectorSearch	Simple web chat experience targeting chatGPT through Azure OpenAI	yyyy-mm-dd	-	-
CaseStudyBotWithVectorSearch	Description	yyyy-mm-dd	-	-
AiPrototypes	Prototypes for PiP	yyyy-mm-dd	-	-
AiAssistant	AI assistant to help with common tasks	yyyy-mm-dd	-	-
flaskApiTutorial	For playing around with basic Flask API functionality	yyyy-mm-dd	-	-
utilities	Utilities to automate admin tasks	yyyy-mm-dd	-	-
AiGf	Ai Girlfriend	yyyy-mm-dd	-	-
PeterFenPoly	Description	yyyy-mm-dd	-	-
JamesBriggsAI	Jupyter Notebooks to help you get hands-on with Pinecone vector databases	yyyy-mm-dd	-	-
GreggKamradtAI	Overview and tutorial of the LangChain Library	yyyy-mm-dd	-	-
PySims	Various models to simulate mining operations	yyyy-mm-dd	-	-
yash_git_tutorial	Description	yyyy-mm-dd	-	-
sdd-auth-server	Description	yyyy-mm-dd	-	-
design_patterns	A library of design patterns in Python	yyyy-mm-dd	-	-
HS2_TPC_Bot	Bot to connect to TPC software and download reports	yyyy-mm-dd	-	-
sdd-frontend	Description	yyyy-mm-dd	-	-
sdd-app-db	Description	yyyy-mm-dd	-	-
sdd-web-scrapers	Description	yyyy-mm-dd	-	-
ViteReactTypescriptTemplate	Description	yyyy-mm-dd	-	-
DevEdNodeJwtTut	Description	yyyy-mm-dd	-	-
public-images	Repo containing public images	yyyy-mm-dd	-	-
WDS-JWT-Auth	Description	yyyy-mm-dd	-	-
TM_express_crash_course	Description	yyyy-mm-dd	-	-
flwebscraper	Description	yyyy-mm-dd	-	-
eskomtenders	Scrapes data off the Eskom tender website	yyyy-mm-dd	-	-
arithmetic-game	Description	yyyy-mm-dd	-	-
genetic-evo	Genetic evolution simulation	yyyy-mm-dd	-	-
AlgoExpert	Solutions the the problems on AlgoExpert	yyyy-mm-dd	-	-
udemy-andrew-mead-react-tutorial	Description	yyyy-mm-dd	-	-
hangmanServer	Server for the hangman game	yyyy-mm-dd	-	-
InventoryApp	Simple inventory management app	yyyy-mm-dd	-	-
Personal-website	Just a fancy CV	yyyy-mm-dd	-	-
Project-euler	Description	yyyy-mm-dd	-	-
end-to-end-testing-with-jest-2883169	Learning End to End Testing with Jest	yyyy-mm-dd	-	-
reed-data-analysis	Description	yyyy-mm-dd	-	-
investment-projection-calculator	Description	yyyy-mm-dd	-	-
digital-management-app	App to manage digital surveys and checklists	yyyy-mm-dd	-	-
credentials-management-app	App to manage corporate credentials - HyperionDev Level 3 Task 35	yyyy-mm-dd	-	-
cars-api	Description	yyyy-mm-dd	-	-
codewithmosh-node-tutorial	A node.js v8.9.1 tutorial with Mosh Hamedani	yyyy-mm-dd	-	-
youtube-traversy-media-mern-tutorial	Code along with Brad's tutorial	yyyy-mm-dd	-	-
jwt-demo-2	Description	yyyy-mm-dd	-	-
jwt-demo	Description	yyyy-mm-dd	-	-
maintenance-app	Description	yyyy-mm-dd	-	-
github-custom-interface	Description	yyyy-mm-dd	-	-
hangman	Description	yyyy-mm-dd	-	-
Coding-challenge	A selection of coding challenges for practice purposes	yyyy-mm-dd	-	-
QuickFoodOrderSystem	Dummy program for food order management system.	yyyy-mm-dd	-	-
Unisa-assignments	Description	yyyy-mm-dd	-	-
Maze-generator	This simple program generates a maze using an iterative back tracking algorithm, using only vanilla JavaScript	yyyy-mm-dd	-	-
JavaScript-canvas-tutorial	Description	yyyy-mm-dd	-	-
Forestry	Software for managing forests	yyyy-mm-dd	-	-
Level1Task25_2	Description	yyyy-mm-dd	-	-
FirstWebsite	My first attempt at building a basic website	yyyy-mm-dd	-	-
MiningVdts	Models the production of a mine with the objective of identifying improvement opportunities	yyyy-mm-dd	-	-
MVVM_Basics_2	Second program to showcase MVVM basics	yyyy-mm-dd	-	-
MVVM_Basics	Demo a simple MVVM design pattern	yyyy-mm-dd	-	-
BasketballRoster	Basketball roster exercise from Head first c#	yyyy-mm-dd	-	-
template	Description	yyyy-mm-dd	-	-
template	Description	yyyy-mm-dd	-	-
Prefix	Document Type	Description
`API`	API Specification	Definitions of endpoints, headers, request/response structures. Includes REST, GraphQL, and OpenAPI files. Use for `.md`, `.yaml`, `.json`.
`BRF`	Backlog Refinement Log	Notes from grooming sessions, including story clarifications, re-estimations, and scope changes. Use `.md`.
`BUR`	Burst Log	Focused development log for a short, time-boxed coding or debugging effort, tied to one WBS and user story. Use `.md`.
`CFG`	Configuration Guide	System/environment setup details (e.g., secrets, variables, local setup). Useful for onboarding. Use `.md`, `.sh`, `.env`, `.ps1`.
`DBS`	Database Schema	Field-level definitions, table relationships, ER diagrams, or migration summaries. Use `.md`, `.sql`, `.drawio`.
`DEC`	Decision Log	Architectural or process decisions with context, alternatives considered, and rationale. Follows ADR format. Use `.md`.
`DIA`	Diagram / Model	Visual system maps, workflows, data flows, or state diagrams. Use as catch-all for visual docs. Use `.md`, `.png`, `.svg`, `.vsdx`, `.drawio`.
`DOC`	General Documentation	Catch-all for concepts, walkthroughs, architecture notes, or unstructured reference material. Use `.md`.
`DSN`	Design Note	UI/UX plans, wireframes, component layout strategies, or design critique. Use `.md`, `.png`, `.fig`, `.drawio`.
`ISS`	Issue Report	Bug reports, technical blockers, unresolved decisions, or open questions. Use `.md`.
`LOG`	General Log	Developer logs that don’t fit into session/burst (e.g., ad hoc, exploratory). Use `.md`.
`MTG`	Meeting Notes	Summaries of syncs, calls, planning meetings, stand-ups, and action points. Use `.md`.
`PBK`	Product Backlog	Master list of all features, epics, and user stories. Use `.md`, optionally `.xlsx` or `.csv` if structured.
`PRJ`	Project Main Page	High-level project summary: vision, scope, goals, constraints, roadmap, planning. Use `.md`.
`REL`	Release / Changelog	Description of features, fixes, and changes released in a version or cycle. Use `.md`.
`REQ`	Requirements	Functional and not functional requirements. Use `.md`.
`RET`	Retrospective	Reflection on what worked, what didn’t, and what to change going forward. Use `.md`.
`RLS`	Sprint Review Summary	Results of demoing sprint output; what was completed, what got feedback. Use `.md`.
`RSR`	Research Note	Technical investigations, tool evaluations, spike results, performance tests. Use `.md`.
`SCR`	Scrum Artifact	Meta documents on Agile process, board structure, sprint cadence, or rituals. Use `.md`.
`SES`	Session Log	Dev session logs that group multiple bursts. Tracks start/end dates, total time, and WBS/user story coverage. Use `.md`.
`SPR`	Sprint Plan	Sprint goals, committed items, estimation notes, and calendar alignment. Use `.md`.
`STD`	Standards / Convent.	Naming conventions, definition of done, linting rules, accessibility, or design standards. Use `.md`.
`TST`	Test Plan / Case	Formal test plans, cases, coverage strategies, and edge-case documentation. Use `.md`, `.xlsx`, or `.json`.
`TMP`	Template	Reusable frontmatter blocks, boilerplate text, or note structure patterns. Use `.md`.
`USG`	Usage / How-to Guide	User-facing guides for system usage, e.g., workflows, UI tasks, keyboard shortcuts. Use `.md`.
`USC`	User Case	Long-form requirement documents tied to end-user outcomes. Table format. For use case diagram use DIA. Often used with WPKs and BURs. Use `.md`.
`USR`	User Story	Short-form requirement documents tied to end-user outcomes. Often used with WPKs and BURs. Use `.md`.
`VEL`	Velocity Report	Historical sprint performance, WIP tracking, and throughput summaries. Use `.md`, optionally `.csv`.
`WPK`	Work Package	Decomposed work unit from a WBS element. Describes scope, dependencies, estimate, and deliverables. Use `.md`.
Document Type	Common File Extensions
Diagram / Model (`DIA`)	`.drawio`, `.vsdx`, `.svg`, `.png`
API Specification (`API`)	`.json`, `.yaml`, `.md`
Database Schema (`DBS`)	`.sql`, `.md`, `.drawio`
Design Notes (`DSN`)	`.md`, `.fig`, `.png`, `.drawio`
Configuration (`CFG`)	`.env`, `.ps1`, `.sh`, `.md`
User Docs & Logs	`.md` (standard format for logs, retros, issues, standards, stories, etc.)
Spreadsheets	`.csv`, `.xlsx` (typically for backlogs, velocity reports, or test matrices)