7.5.4.4 Next Actions

• Fix Bug
• Make the charts more intuitive, and interactive for the end user.

7.6 Final Technical Report

7.6.1 Project Summary

[Brief recap of what the project is and its purpose]

7.6.2 Development Process

[How the project was developed step-by-step]

7.6.3 Features Implemented

[List of final features and modules]

7.6.4 Technical Specifications

[Full specs, APIs, protocols used]

7.6.5 Testing & Validation

[Testing approach, tools used, and results]

7.6.6 Lessons Learned

[Key takeaways and improvements for next time]

7.6.7 Future Work

[Potential next versions, enhancements, or research]

7.6.8 Appendices

[Extra charts, diagrams, or detailed reference material]

Template generated by ChatGPT
Compendium section: 10-docs
Title: Project CodexHub
Author: Joe Corso
Tags: [project, infastructure, devlog, build, docs]
Status: [ Draft / Final / Reviewed ]
Template:
- 00-project-proposal.md
- 01-project-overview.md
- 02-design-report.md
- 03-technical-report.md
- 04-research-log.md
- 05-final-report.md
License: “All Rights Reserved”
Schema: technical
Version: 0.0.1
Branding: Operation Starship

8 Project Interlink

8.1 Project Proposal

8.1.1 Project Title

Project Interlink

8.1.2 Author(s)

Joe Corso

8.1.3 Date

01-21-2024

8.1.4 Problem Statement

It takes too long to manually write every form and report you need for a database

8.1.5 Objectives

• Simplify and automate CRUD interface generation from live MySQL schemas.
• Provide reusable security decorators and templating tools for Flask apps.
• Enable developers to focus on business logic, not boilerplate.
• Logic for templates, forms, and routing are in separate modules.
• Modular enough to plug into any Flask-based backend.

8.1.6 Scope

• Form, and Report generating with Flask/MySQL
• Web Development
• Template Building

8.1.7 Benefits

Automate the generation of forms, reports, navigation, and access controls

8.1.8 Risks & Challenges

• Robust Security

8.1.9 Resources Needed

• Flask
• Python
• Web Development Skills

8.2 Project Overview

8.2.1 Purpose

Interlink reduces time-to-deploy for data-heavy applications by abstracting away routine form and report logic. It streamlines software operations and automates flask appications at the infrastructure level.

8.2.2 Background

NA

8.2.3 Overview

By consolidating templating, access control, and DB-driven form/report logic, Interlink provides a minimalist yet powerful platform that complements Flask’s ecosystem. Interlink is a modular, Flask-based Python framework designed to accelerate development of data-driven web applications. Interlink automates the generation of forms, reports, navigation, and access control based on MySQL database schemas. The system offers a low-code solution for rapidly building internal tools and administrative dashboards without sacrificing control or customizability.

8.2.4 Key Features

• formulator: Generates HTML forms and reports directly from database tables.
• templeton: Provides a templating layer and ready-to-use Flask Blueprints for common views.
• safeHaven: Offers pluggable security decorators (@requireLogin, @honeypot, etc.) to protect routes.
• toolkit: A utility module for DB connections, route registration, and view generation automation.

8.2.5 Target Audience

• Backend developers building internal web tools.
• Teams managing CRUD-heavy applications.
• Flask developers seeking rapid prototyping frameworks.

8.2.6 Expected Impact

Interlink is a practical, extensible framework that embodies the PADS philosophy: less boilerplate, more velocity. It empowers developers to move fast, stay organized, and build interfaces that just work — all while keeping security and modularity at the forefront.

8.3 Design Report

8.3.1 Architecture Overview

8.3.1.1 Modular Structure

• formulator: Converts database schema into HTML forms and CRUD views.
• templeton: Template engine wrapping Flask views into standard layouts.
• safeHaven: Route protection and authentication decorators.
• toolkit: Utility functions for route registration, DB I/O, and schema parsing.

8.3.1.2 Blueprint-Based Routing

Each module can be loaded as a Flask Blueprint, allowing independent development and integration. Navigation, view registration, and auth middleware are initialized at the application level.

8.3.2 Technology Stack

• Flask
• MySQL
• Jinja2
• Python

8.3.3 Data Flow

8.3.3.1 Directory Structure

/interlink/src/interlink
├── formulator
│   ├── __init__.py
│   └── logic.py
├── __init__.py
├── __main__.py
├── safeHaven
│   └── __init__.py
├── templeton
│   ├── __init__.py
│   ├── templates
│   │   ├── 404.html
│   │   ├── 500.html
│   │   ├── admin.html
│   │   ├── copyright.html
│   │   ├── data.html
│   │   ├── forms.html
│   │   ├── guide
│   │   │   └── index.html
│   │   ├── login.html
│   │   ├── nav.html
│   │   ├── reports.html
│   │   ├── template.html
│   │   └── templeton.html
│   └── views.py
└── toolkit
    └── __init__.py

• Diagram – Module Interaction

  ┌─────────────┐    ┌──────────────┐
  │  formulator │───▶│   templeton  │
  └─────────────┘    └──────────────┘
         │                   │
         ▼                   ▼
  ┌─────────────┐    ┌──────────────┐
  │  safeHaven  │    │   toolkit    │
  └─────────────┘    └──────────────┘

8.3.4 UI/UX Design

A minimal UI approach is taken by default, but templates are overrideable using Jinja2 template inheritance. Menus and layouts are dynamically generated based on the database schema and user permissions.

8.3.5 Security Considerations

• Currently optimized for MySQL. PostgreSQL and SQLite support planned.
• Tight coupling to Flask—porting to FastAPI would require wrapper layers.

8.3.6 Scalability Plan

• Plugin system for frontend themes
• Admin dashboard with configurable widgets
• CLI scaffolding for new project generation

8.4 Technical Report

8.4.1 Introduction

Interlink is a Flask-compatible backend library suite that generates form interfaces, reporting views, and access-controlled pages based on MySQL table schemas. It follows a plugin architecture with four core modules: formulator, templeton, safeHaven, and toolkit.

8.4.2 Problem Statement

Clearly define the technical challenge or need that this report addresses.

8.4.3 Methodology

Describe the processes, tools, and technologies used to address the problem.
Include diagrams, charts, or pseudocode if applicable.

8.4.4 Implementation Details

interlink.formulator

• Reflects table schema using SHOW COLUMNS.
• Generates GET/POST routes for forms.
• Handles input validation and DB inserts/updates.

interlink.templeton

• Manages layout templates.
• Provides base HTML and page blocks via Jinja2.
• Dynamically creates menus from registered Blueprints.

interlink.safeHaven

• Includes decorators like @requireLogin, @honeypot, etc.
• Middleware setup for session control.
• Provides helper utilities for role management.

interlink.toolkit

• DB connector using pymysql.
• Auto route-loader from config or metadata.
• Markdown-to-HTML conversion for embedded docs.

8.4.5 Results

• Integrated into Flask via Blueprint registration.
• Configurable via environment or .env settings.
• Supports local dev server (flask run) or WSGI deployments.

8.4.6 Analysis

• Speedy Web App Development

8.4.7 Challenges & Limitations

• Tight coupling to MySQL only.
• Lacks full test coverage on edge-case inputs.
• Blueprint auto-discovery can be brittle if paths are misconfigured.

8.4.8 Recommendations

• Full test coverage with CI integration.
• PostgreSQL and SQLite backend support.
• Admin GUI for live schema editing and form regeneration.

8.4.9 Conclusion

What it lacks for in developers, it makes up for in development.

8.4.10 References

• NA

8.5 Research Log

“Running record of steps, discoveries, and next actions.”

8.5.1 2026-03-15

Next →

8.5.1.1 Summary

Cleaned up a lot of the files to make it resemble a MVC concept a little better.

Started working on a CLI version. I hope it could be useful for throwing up a report in the terminal real quick; as opposed to starting a server, etc. I think in the future, the output could be piped to a separate text file that could be printed or maybe incorporated in an LLM. I worked on it a few weeks ago, and did write the research so this is in hind sight, and I don’t remember the steps.

I was getting tired of trying to figure out how to set up this lib each time I needed to work on it, so I created a few new directories to just put everything I needed into the proper directories. tests for tests, scripts for setup and runtime, examples to build a working demo. Also a tree.txt file in docs.

8.5.1.2 Steps Taken

1. Build dirs:
   

  $ mkdir {tests,examples,scripts,docs}

2. Setup test project:
   

  $ mkdir tests/dev
  $ python -m venv tests/dev/venv
  $ . tests/dev/venv/bin/activate
  $ python -m pip install --upgrade pip
  $ python -m pip install -e ~/code/interlink

3. Build Flask project (I just copied from an old setup using interlink already).

4. Add src/interlink/__main__.py file. So that interlink can be run from the command line (i.e. python -m interlink)

5. Install click, add as a dependancy to pyproject.toml file.
   

  $ python -m pip install click
  
  -> pyproject.toml
  dependencies = [
  "flask>=2.3",
  "mysql>=0.0.3",
  "mysqlclient>=2.2.7",
  "mysql-connector>=2.2.9",
  "click>=8.3.1"
  ]

8.5.1.3 Observations & Notes

• This CLI may or may not be necessary, and won’t be an overall priority until it become more important.

8.5.1.4 Problems / Challenges

• The data is being parsed as a tuple within an array. The tuple is a list with the results as each position as opposed to each record being a new position within the tuple. This makes it difficult to separate each record properly. You would have to sanitize the data differently or parse the data from the Generator differently. Using a delimiter would yield inaccurate results, as whitespace or a newline would just separate each position in the tuple regardless of if it’s the same record or not. Using specific strings or integers would be inaccurate, as the PID may be an unspecified length of integers and strings. It may be possible to search for the PID, and then use that as the delimiter in a for loop. Like “For each instance of PID, start a new line.”

8.5.1.5 Next Actions

• Tasks for tomorrow or next session

8.5.2 2026-03-18

← Previous | Next →

8.5.2.1 Summary

Refactoring some code, so it makes more sense. I noticed that the description in the Generator class was the same as the DB class.

8.5.2.2 Steps Taken

1. Moved the function getFormData() into the class formulator.Generator.generateForm()
   
2. Moved the functions getDatabase(), getTables(), getEnumData(), getMetadata() to a new class DataHandler
   
3. Changed the example in the Generator class to make more sense.

8.5.2.3 Observations & Notes

• Breakout cable pin mismatch caused first detection failure.
  
• Older firmware on HBA required flashing to IT mode.

8.5.2.4 Problems / Challenges

• Need better airflow — drives running hot.

8.5.2.5 Next Actions

• Order fan shroud.
  
• Test with mixed SAS/SATA drives.

8.5.3 2025-08-14

← Previous | Next →

(Continue adding sections for each workday or session)

8.6 Final Technical Report

8.6.1 Project Summary

Interlink is a modular Python/Flask library suite that automates the generation of CRUD forms, tabular reports, and navigation menus from MySQL database schemas. Its purpose is to drastically reduce development time for database-driven web applications while ensuring consistent design, maintainable code, and built-in security.

8.6.2 Development Process

1. Requirements Gathering – Identified the need for automated form/report generation in Flask projects.
   
2. Module Planning – Split into four logical components: formulator, templeton, safeHaven, and toolkit.
   
3. Database Integration – Connected to MySQL using SQLAlchemy, with schema introspection via INFORMATION_SCHEMA.
   
4. Form Generation – Implemented dynamic Flask-WTF form creation from table definitions.
   
5. Template System – Created Jinja2 templates with theme and layout inheritance.
   
6. Security Layer – Developed authentication/authorization decorators in safeHaven.
   
7. Utility Layer – Added config parsing, logging, and database utilities in toolkit.
   
8. Blueprint Packaging – Each generated module can be plugged into a Flask app as a Blueprint.
   
9. Testing – Performed unit, integration, and UI testing before deployment.

8.6.3 Features Implemented

• Automatic CRUD Form Generation from MySQL schema.
  
• Dynamic Report Rendering with pagination and filtering.
  
• Navigation Menu Builder based on registered Blueprints.
  
• Security Decorators for route access control.
  
• Blueprint Integration for modular Flask applications.
  
• Theme/Template Management through templeton.
  
• Database Utility Functions for configuration, logging, and schema queries.

8.6.4 Technical Specifications

• Language: Python 3.x
  
• Framework: Flask
  
• Database: MySQL (via SQLAlchemy ORM)
  
• Templating: Jinja2
  
• Forms: Self Generating
  
• Security: Flask-Login, custom decorators (safeHaven)
  
• Configuration Files: ENV VARS in .env file
  
• APIs: Internal Python API for module calls.
  
• Protocols: HTTP/HTTPS (Flask server), WSGI compatibility.

8.6.5 Testing & Validation

• Unit Testing: Covered form creation, report rendering, and security decorators using pytest.
  
• Integration Testing: Verified end-to-end request/response for generated routes.
  
• UI Testing: Manual browser-based testing for template rendering and navigation.
  
• Database Validation: Confirmed schema parsing and CRUD accuracy with sample MySQL databases.
  
• Result: All core modules functioned as designed with stable performance and no major security gaps identified.

8.6.6 Lessons Learned

• Schema introspection can vary across database vendors — future-proofing for PostgreSQL and SQLite will require abstraction layers.
  
• Dynamic code generation works well but needs careful error handling for missing or malformed schemas.
  
• Templating flexibility is key — early investment in a clean template hierarchy paid off in maintainability.
  
• Security must be baked in early — retrofitting auth is more painful later.

8.6.7 Future Work

• Add support for PostgreSQL and SQLite.
  
• Implement drag-and-drop form designer GUI.
  
• Add inline editing capabilities to reports.
  
• Develop a REST API generator for headless use.
  
• Support internationalization (i18n) and multilingual forms.
  
• Introduce theme marketplace for community-driven templates.

8.6.8 Appendices

License: “All Rights Reserved”
Schema: technical
Version: 0.1.1
Branding: Operation Mindmap

version

1.2.1

author

Joe Corso

date

01-21-2024

updated

02-22-2026

copyright

Copyright 2024 Joe Corso

license

MIT License

email

pads.email.address@gmail.com

status

Production

description

Flask Generator for Forms, Reports, URLs and Templates.

8.7 interlink

Flask Generator for Forms, Reports, URLs and templates.

This is a collection of libraries written to work in Python’s flask framework. It will generate a form and report for any table in a database. It will also create the urls, and the navigation bar. You can customize your website by generating your own instance of the API; or you can register the Blueprint(e.g. app.register_blueprint(templetonBP)), which has its own set of templates.
So essentially, if you create a database for a library like in all tutorials and you need a form template and a report template, it will generate the form or report from the table in the database, and fill in the details in the template. To render the page in the browser just type in the url which corresponds to the table name, or make a navigation bar to generate the links for you.

Examples:

Setting up interlink is very easy. It depends on mysql-connector, and flask. Which will be downloaded automatically when installed. Let’s say we want to make a blog, and we have a database named “blog” with a table named “manifest”. This documentation is not in the same scope of writing SQL, we will assume you’ve set up your blog any way you want. That’s the beauty of interlink, it doesn’t matter.

1. First create your database, and tables. Then build your flask project, activate your virtual env, and install interlink:

        $ python -m venv path/to/venv/my_env
        $ . path/to/venv/my_env/bin/activate
        $ python -m pip install git+https://github.com/padsRepo/interlink.git

2. There are a few enviroment variables that need to be set to get full functionality from Interlink. These variables can be placed in an .env file for best practices. This documentation shows the full __init__.py file for easier reading.

    __init__.py
        import os
        from flask import Flask, Blueprint, render_template, url_for
        from views import viewsBP

        KEY = os.urandom(16)
        os.environ['SECRET_KEY'] = str(KEY) # REQUIRED
        os.environ['DB_USER'] = '<username>' # REQUIRED
        os.environ['DB_PASS'] = '<password>' # REQUIRED
        os.environ['BASE_DIR'] = os.path.dirname(__file__)
        os.environ['LOG_DIR'] = os.environ.get('BASE_DIR') + '/log'
        os.environ['whitelist'] = '["127.0.0.1", "192.168.0.37"]' # REQUIRED
        os.environ['blacklist'] = '["71.71.71.71"]' # REQUIRED

        app = Flask(__name__)
        app.config.from_mapping(SECRET_KEY=os.environ.get('SECRET_KEY'))
        app.config['UPLOAD_FOLDER'] = 'repo/'

        from interlink import *
        app.register_blueprint(viewsBP) # Your views.py file
        app.register_blueprint(templetonBP) # Add to use interlinks templating engine
        app.register_error_handler(404, url_not_found) # From the templeton lib
        app.register_error_handler(500, internal_error) # From the templeton lib

        if debug == False:
         app.run(debug=True, host='0.0.0.0', port='8000')
         

3. The templetonBP has all the templates you need. There is a default admin, forms, reports, blog, login, index page, and its own documentation. It helps to load the templetonBP after your own library. If you have variables set outside the scope of the __init__.py file, interlink will not find them.
   Enter the URL into the browser, interlink also has it’s own navigation bar:

        127.0.0.1:8000/admin/blog
        127.0.0.1:8000/forms/blog/manifest
        127.0.0.1:8000/reports/blog/manifest
        127.0.0.1:8000/blog/manifest # for the blog you want everyone to see
        127.0.0.1:8000/admin/blog
        127.0.0.1:8000/copyright/
        127.0.0.1:8000/404/
        127.0.0.1:8000/500/
        127.0.0.1:8000/docs/<page>/ # the docs page for this library.
        127.0.0.1:8000/loginRequired/
        127.0.0.1:8000/login/
        127.0.0.1:8000/register/
        127.0.0.1:8000/index/

4. tying in navigation to interlink from your first index file.

8.8 toolkit

This is the Toolkit Module. It contains classes and functions that are reuseable across the entire library.

8.8.1 get_script_path

Get the directory path of the project

8.8.2 site_map

Generate a URL for each view that does not have a GET or POST method.

8.9 formulator

The formulator is used as the SQL engine to gather the data from the database to populate the template.

The formulator module makes use of the Generator() object, to connect to the database, find the proper table, query the results, and return a value that can be passed into an html template. It is the main module behind the Interlink library. It acts as the SQL engine, to generate a return value, that can be manipulated to the developers needs. It’s main dependancy is the toolkit.DB() object for connection to a database. Make sure you have the proper environment variables set to ensure proper connection. If the project does not fit into the templetonBP this module will assist in automating redundant SQL statements, form, and report development, and navigation menus which need to sort administration, from users, from bad actors. It can be used along side other modules in the library as well as imported directly into your own project.

Let’s say you dont like templetons blog template and you want to use your own blog template. Use the formulator.Generator to make a query of your blog table from your SQL database. Create a variable from it, and then using Jinja’s Templating Engine with Flask, we can manipulate the variable in an html template anyway we want.

In your views.py file you only need two specific views that will generate every form, and report respectively. In the index() function you will see the nav variable set to generateNav(). This generates the navigation bar for you. It can be used in the template to build the navigation menu. If you’re familiar with flask’s Blueprints, then this should look pretty simple. If not, check out the flask docs, it’s pretty cool.

Basically, make a route for a reports url and a route for a forms url so that the computer doesn’t confuse the two. For your route you need to define a parameter for your database, and table. This is just to pass into the generateReport() or generateForm() functions which is used to find the table, and create the form or report. The report needs 4 parameters(One for the column names of the table, one for the data in the table, a title, and a generic error) and the form needs 3(One to generate the forms, a title, and a generic error). The generateNav() doesn’t need a parameter, but it searches for the database you set to your Generator.__init__(). Make sure to register the views:

    __init__.py

      from views import viewsBP
      app.regist_blueprint(viewsBP)

    views.py

      from flask import Blueprint, render_template
      import interlink as i

      viewsBP = Blueprint('/', __name__, url-prefix='/')

      @viewsBP.route(/)
      def index():
        gen = i.Generator('DB', 'DB_USER', 'DB_PASS')
        nav = gen.generateNav()
        return render_template('index.html', nav=nav)

      @viewsBP.route('/<db>/<table>')
      def blog(db, table):
        gen = Generator(db, 'DB_USER', 'DB_PASS')
        content = gen.generateQuery(table)
        return render_template('template.html', content=content)

      @viewsBP.route('/reports/<db>/<table>')
      def generateReport(db, table):
        gen = i.Generator(db, 'DB_USER', 'DB_PASS')
        colName, colRow, error, title = gen.generateReport(table)
        return render_template('reports.html', colName=colName, colRow=colRow, error=error, title=title)

      @viewsBP.route('/forms/<db>/<table>', methods=['GET', 'POST'])
      def generateForm(db, table):
        gen = i.Generator(db, 'DB_USER', 'DB_PASS')
        error, form, title = gen.generateForm(table)
        return render_template('forms.html', form=form, error=error, title=title)

      @viewsBP.route('/admin/<db>')
      def admin(db):
        nav = Generator(db, 'DB_USER', 'DB_PASS').generateNav()
        return render_template('admin.html', nav=nav, db=db, title=db)

Make a template for your Forms:

      forms.html

      {% extends 'base.html' %}
      {% block description %}{% endblock %}
      {% block keywords %}{% endblock %}
      {% block title %}{{ title }}{% endblock %}

      {% block content %}

      <article class="index">
        <section class="col-6 col-s-6 col-m-6">
          <fieldset class="form">
            <label>{{ error }}</label>
            <form method="POST">
              {% for f in form %}
                <label for="{{ f[0] }}">{{ f[0] }}</label>
                <input type="text" name="{{ f[0] }}">
              {% endfor %}
              <input type="submit" value="submit">
            </form>
          </fieldset>
        </section>
      </article>

      {% endblock %}

Make a template for your reports:

      reports.html

      {% extends 'base.html' %}
      {% block description %}{% endblock %}
      {% block keywords %}{% endblock %}
      {% block title %}{{ title }}{% endblock %}

      {% block content %}

        <article class="col-12 col-s-12 col-m-12">
          <h1>{{ title }} Report</h1>
          {{ error }}
          <table class="data">
            <tr>
              {% for c in colName %}
                <th>{{ c[0] }}</th>
              {% endfor %}
            </tr>
            {% for row in colRow %}
              <tr>
                {% for c in row %}
                <td>{{ c }}</td>
                {% endfor %}
              </tr>
            {% endfor %}
          </table>
        </article>

      {% endblock %}

Finally, make a navigation menu for it all. The formulator filters “timestamp”, “pri”, “uni”, “mul”, “updated”, and “q”.

      base.html

      <nav class="pc mobile">
        <a href="{{ url_for('/.index') }}">Index</a>
        <div class="dropdown">
          <span>Reports</span>
          <div class="dropdownContent">
            {% for p in nav %}
            <a href="{{ url_for('templeton.generateReport', db='{}'.format(db),  page='{}'.format(p[0])) }}">{{ p[0] }}</a>
            {% endfor %}
          </div>
        </div>
        <div class="dropdown">
          <span>Forms</span>
          <div class="dropdownContent">
            {% for p in nav %}
            <a href="{{ url_for('templeton.generateForm', db='{}'.format(db),  page='{}'.format(p[0])) }}">{{ p[0] }}</a>
            {% endfor %}
          </div>
        </div>
      </nav>

That’s it! So if you have a DB with tables named books, authors, planets, solarSystems….etc. Just type in the url for the table name. For example:

https://www.website.com/reports/library/authors
https://www.website.com/reports/library/books
https://www.website.com/forms/library/authors
https://www.website.com/forms/library/books
OR
https://www.website.com/reports/science/solarSystems
https://www.website.com/reports/science/planets
https://www.website.com/forms/science/solarSystems
https://www.website.com/forms/science/planets

8.9.1 DB

The DB class is designed to facilitate operations on databases using MariaDB. It enables you to establish connections to your database with credentials that possess appropriate permissions. Ensure you close the connection after completing your operations to avoid potential resource leaks.

Example:

    os.eviron['db'] = 'library'
    os.eviron['user'] = 'franklin'
    os.eviron['password'] = 'aklsdjhashdfsajkdfh'
    @viewsBP.route('/report/<db>/<page>')
    def myFuntion(db, user, password):
      db_conn = DB(db, user, password).connect()
      cursor = db_conn.cursor(buffered=True)
      cursor.execute(f"SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='{db}'; ")
      sql = cursor.fetchone()
      db_conn.close()
      return sql

8.9.1.1 init

Initialize the database object

8.9.1.2 str

None

8.9.1.3 repr

None

8.9.1.4 connect

Used to make a connection to MariaDB

8.9.1.5 close

Used to close a connection to MariaDB

8.9.2 DataHandler

The DataHandler class is designed to manage various data operations related to databases, including fetching database and table names, retrieving enumerated list data, and obtaining metadata.

8.9.2.1 init

None

8.9.2.2 getDatabase

Get Database Names which the user has access to.

8.9.2.3 getTables

Get Table Names from a specific Database which the user has access to.

8.9.2.4 getEnumData

Retrieve HTML options for enumerated lists from a given table.

8.9.2.5 getMetadata

Obtain metadata related to foreign keys in a specified table.

8.9.3 Generator

The generator is the module used to generate your forms, reports, queries, and anything DB related. It wraps the core functionality of the modeule into a reusable Class Object which you can use to recall a connection or query to a specifc database and table. In practice, the developer would not have to write the boilpate code needed to connect, query, and close connection to the database. By leveraging the concept of OOP, the intent is to mitigate, and slow down DDOS attacks, by preventing the end user from creating multiple concurrent conections to any given website.

Example:

    @templetonBP.route('/blog/')
    @honeypot
    @backdoor
    def blog():
      gen = Generator('blog', 'DB_USER', 'DB_PASS')
      colName, colRow, error, title = gen.generateReport('blog')
      return render_template('blog.html', colName=colName, colRow=colRow, error=error, title=title)

8.9.3.1 init

Initialize the Generator object. This would, in theory, create a new object in the session which the server could point back to.

8.9.3.2 str

None

8.9.3.3 repr

None

8.9.3.4 generateForm

Generate a form using table name to populate the form.html template.

TODO:
- Find better terms for the functions and values of data and enumList

Example:

    @templetonBP.route('/forms/<db>/<page>', methods=['GET', 'POST'])
    @backdoor
    @login
    @honeypot
    def generateForm(db, page):
      gen = Generator(db, 'DB_USER', 'DB_PASS')
      error, form, data, enumList, title = gen.generateForm(page)
      return wrapper('forms.html', form=form, error=error, title=title, data=data, enumList=enumList)

8.9.3.5 generateReport

Generate a report using table name to populate the report.html template.

Example:

    @templetonBP.route('/reports/<db>/<page>')
    @backdoor
    @login
    @honeypot
    def generateReport(db, page):
      gen = Generator(db, 'DB_USER', 'DB_PASS')
      colName, colRow, error, title = gen.generateReport(page)
      return wrapper('reports.html', colName=colName, colRow=colRow, error=error, title=title)

8.9.3.6 generateQuery

Run a custom SELECT statement to see the results.

TODO:
- Add *args to select different columns.

8.9.3.7 generateNav

Generate a URL for each table in a db, which the user has access. This is useful within an Admin Page, to generate a url for each form or report of the table.

Example:
-> views.py

    @templetonBP.route('/admin/<db>')
    @backdoor
    @login
    @honeypot
    def admin(db):
      nav = Generator(db, 'DB_USER', 'DB_PASS').generateNav()
      return wrapper('admin.html', nav=nav, db=db, title=db)

-> base.html

    <div class="adminNav col-5">
      <h2>Reports:</h2>
          {% for p in nav %}
            <a href="{{ url_for('templeton.generateReport', db='{}'.format(db),  page='{}'.format(p[0])) }}">{{ p[0] }}</a><br>
          {% endfor %}
    </div>
    <div class="adminNav col-5">
      <h2>Forms:</h2>
          {% for p in nav %}
            <a href="{{ url_for('templeton.generateForm', db='{}'.format(db),  page='{}'.format(p[0])) }}">{{ p[0] }}</a><br>
          {% endfor %}
    </div>

8.9.3.8 generateURL

Generate a URL for each db, which the user has access. This is useful to generate a navigation bar in a base.html file, to access each database. Which would lead you to an admin page to generate a url for each table within the database.

Example:
-> views.py

     @templetonBP.route('/dashboard/')
     def dashboard():
       database = Generator('', 'DB_USER', 'DB_PASS').generateURL()
       return render_template('data.html', database=database)

-> base.html

    {% for d in database %}
      <li><a href="{{ url_for('templeton.admin', db='{}'.format(d[0])) }}" title="{{ d[0] }} Panel"><img src="{{ url_for('templeton.static', filename='/img/icons/ai-settings2-t.png') }}"><span>{{ d[0] }}</span></a></li>
    {% endfor %}

8.10 safeHaven

Safe Haven is like the security team for the president. Always lurking in the shadows, ready to defend your best interest. Since these are decorators they’re easy to use.

Python Decorators

All you have to do is add the appropriate decorator to each page that you want to add the functionality to. Here’s a simple index page, that I want really locked down.

@viewsBP.route('/')
@backdoor
@honeypot
@login
def index():
  return render_template('index.html')

And there’s nothing more to it then that. Safe Haven checks that the person connecting passes, and if not redirects them to the appropriate page. If you’re using templeton’s Blueprints it will redirect to its login screen, and everything works seamlessly.

8.10.1 honeypot

Python decorator you can use as a honeypot. Any IP Adress that is black listed will be redirected to a login page that logs the username and password they attempt to use.

8.10.2 backdoor

Python decorator you can use as a backdoor. Any page which has this decorator will give IP Address’ on the whitelist full access to the page.

8.10.3 login

Python decorator you can use to check if a user is logged in. If not, they will be redirected to a login page from where they can log in.

8.11 cli

This module is used to access Interlink from the CLI.

8.11.1 Model

Test Model

8.11.1.1 init

None

8.11.1.2 report

None

8.11.2 cli

CLI Mode

8.11.3 report

Generate a report for table

8.11.4 colors

This script prints some colors. It will also automatically remove all ANSI styles if data is piped into a file.

Give it a try!

8.12 templeton

Templeton is like the butler used to fetch the templates, fill in the proper parameters, and serve it to you on a silver platter. Templeton builds the skeleton website for you. All you have to do is type in the proper URL, or generate the navigation bar.

The easiest way to use templeton is to register its Blueprint’s in your app. There are three; 404, 500, and templetonBP.

  -> __init__.py
      from interlink.templeton.views import templetonBP
      app.register_blueprint(templetonBP)
      app.register_error_handler(404, url_not_found)
      app.register_error_handler(500, internal_error)

The templetonBP has a default set of templates you can use to have a full website deployed. The URL’s which Templeton uses are as follows:

      127.0.0.1:8000/admin/<db>
      127.0.0.1:8000/forms/<db>/<table>
      127.0.0.1:8000/reports/<db>/<table>
      127.0.0.1:8000/<db>/<table> # for the blog you want everyone to see
      127.0.0.1:8000/admin/<db>
      127.0.0.1:8000/copyright/
      127.0.0.1:8000/404/
      127.0.0.1:8000/500/
      127.0.0.1:8000/docs/<page>/ # the docs page for this library.
      127.0.0.1:8000/loginRequired/
      127.0.0.1:8000/login/
      127.0.0.1:8000/register/
      127.0.0.1:8000/index/

Whatever the name of the database, type the name into the db parameter. Whatever the name of the table, type the name into the table parameter. It will generate a generic template for you.

The Tempulations are used to build a new url rule, based on the developers needs.

[!NOTE]
Remember that with templeton’s tempulator, the generic templates are only coming from interlink.templeton.views. If you want to change where it’s coming from you can use templeton’s Tempulation, and create a new url loader function.

Templeton also comes equiped with a tempulator, which runs off of Tempulations. The tempulator is basically just Flask Lazy Loading URL’s in a wrapper. This feature is used to route Templetons templates to a URL, but does not have an endpoint(e.g. does not load by default). It is used to add extra templates to the app, if needed, without added overhead to the base project. For example, if you make a blog, you should be able to build a blog without also loading the catalog from an ecommerce site into memory, and vice versa. By using the tempulator, you can load a blog without a journal, or an ecommerce site without a repository, or a snosberry without an everlasting gobbstopper. You can also use the tempulator to load one endpoint before the other. If you like templetons catalog view, and you’re an ecommerce site you may want to load that as your index page. This would achieve those results. If you like the admin page, but need it rerouted to another URL, you would use templulator.

8.12.1 Tempulation

Generate a new url_rule from any view within your project. This is used if you would like to map out url rules for each of your own endpoints.

Examples:

# Use the Tempulation's to create a new URL:
app.add_url_rule('/dash', view_func=Tempulation('interlink.templeton.views.dashboard'))

# make a new tempulator
def myNewTempulator(import_name, url_rules=[], **options):
    view = Tempulation(f"@{app_name@}.@{import_name@}")
    for url_rule in url_rules:
      app.add_url_rule(url_rule, view_func=view, **options)

8.12.1.1 init

Initialize the Tempulation object. This will hold the variable for the new url_rule.

8.12.1.2 view

None

8.12.1.3 call

None

8.12.2 tempulator

The tempulator is used to add extra templates to the app, if needed, without added overhead to the base project. For example, if you make a blog, you should be able to build a blog without also loading the catalog from an ecommerce site into memory, and vice versa. By using the tempulator, you can load a blog without a journal, or a ecommerce site without a repository, or a snosberry without an everlasting gobbstopper. You can also use the tempulator to load one endpoint before the other. If you like templetons catalog view, and you’re an ecommerce site you may want to load that as your index page. This would achieve those results.

--> views.py  
# load templetons catalog view as the index view
@templetonBP.route('/')
@login
def catalog():
  return tempulator("views.catalog", ['/catalog'], app = app)

# add a single route to the catalog view
tempulator('views.catalog', ['/catalog'], app = app)

# add two routes to a single function endpoint
url_rules = ['/catalog/','/catalog/<item>']
tempulator('views.catalog', url_rules, app = app)

8.12.3 wrapper

Used to wrap all the web pages in default params.

TODO:
- Make a decorator.

9 Project MakeMe

9.1 Project Proposal

9.1.1 Project Title

MakeMe

9.1.2 Author(s)

Joe Corso - Lead Developer

9.1.3 Date

2025-11-15

9.1.4 Problem Statement

[Describe the problem this project solves]

9.1.5 Objectives

[List the main objectives]

9.1.6 Scope

[Define the boundaries of the project: what’s included/excluded]

9.1.7 Benefits

[Key benefits and value proposition]

9.1.8 Risks & Challenges

[Potential issues and mitigation plans]

9.1.9 Resources Needed

• Creality Ender-3

9.1.10 Approval

[Sign-off or decision to proceed]

9.2 Project Overview

9.2.1 Purpose

9.2.2 Background

NA

9.2.3 Overview

9.2.4 Key Features

9.2.5 Target Audience

9.2.6 Expected Impact

NA

9.3 Design Report

9.3.1 Architecture Overview

• Board: Raspberry Pi 3B (ARMv8, 1GB RAM)
• Storage: 64GB SD card (boot/root), optional USB SSD for persistent storage
• Power: 5V micro-USB power adapter
• Cooling: Passive heatsink or low-noise fan
• Networking: Ethernet preferred; Wi-Fi fallback

9.3.2 Technology Stack

• Git server via git-shell or gitea
• Documentation served via paddocs-generated HTML
• Network tools (ping, traceroute, nmap, etc.)
• Remote backup target via rsync or restic
• Flask/Python app testing for local development
• Jellyfin for media

9.3.3 Data Flow

[How data moves through the system, with diagrams if needed]

9.3.4 Bill of Materials

Build Date: 2025-07-09
Designed for: llama.cpp (3B–7B CPU Inference), Arch Linux, Headless/Server Ready
Estimated Power: ~150W max (CPU-only), ~300W w/ GPU
Target Use: Local LLMs, PADS builder, dev server

9.3.4.1 Components

9.3.4.2 Total

Estimated Total: $426.73

All prices are approximate from Amazon as of July 2025. Tax/shipping not included.

9.3.4.3 Optional (Not Included)

9.3.4.4 BOM Metadata

project: llama-arch-box
date: 2025-07-09
format: markdown
target_model: llama.cpp q4/q5 (3B–7B)
ram_min: 16GB
ram_recommended: 32GB
gpu_required: false

9.3.5 Directory Structure

/mnt
├── media        # Jellyfin Server
│   ├── games
│   ├── movies
│   ├── music
│   ├── pics
│   └── shows
└── repo
    ├── archive  # Backups
    ├── code     # Libs used for RPi
    └── git      # Local Repo

9.3.6 UI/UX Design

[Wireframes, mockups, or descriptions of user interactions] ### Security Considerations

• All remote access via SSH with key authentication
• Encrypted backups and secrets stored under vault/
• Minimal services exposed; firewall configured with ufw

9.3.7 Scalability Plan

• Add Pi-hole, local DNS or DHCP
• Integrate ZeroTier or Tailscale for remote VPN
• Deploy model evaluation or inference client
• Expand with external SSD, NAS, or other SBCs

9.4 Technical Report

9.4.1 Introduction

Provide background information, objectives, and the scope of the technical work.

9.4.2 Problem Statement

Clearly define the technical challenge or need that this report addresses.

9.4.3 Methodology

Describe the processes, tools, and technologies used to address the problem.
Include diagrams, charts, or pseudocode if applicable.

9.4.4 Implementation Details

Explain how the solution was developed or executed.
List hardware, software, configurations, or environments used.

9.4.5 Results

Present the findings, data, or performance outcomes of the technical work.
Include tables, graphs, or screenshots where relevant.

9.4.6 Analysis

Interpret the results and discuss their significance.
Highlight successes, issues, and unexpected outcomes.

9.4.7 Challenges & Limitations

List any technical constraints, risks, or difficulties encountered.

9.4.8 Recommendations

Suggest improvements, next steps, or further areas of research.

9.4.9 Conclusion

Summarize the technical achievements and how they meet the project goals.

9.4.10 References

List all technical references, standards, and documentation sources.

9.5 Research Log

“Running record of steps, discoveries, and next actions.”

9.5.1 2025-11-14

Next →

9.5.1.1 Summary

Setting up the Ender-3 after it’s been sitting in the closet for about a year. The firmware was wiped in a catastrophic boating accident.

9.5.1.2 Steps Taken

1. Find the firmware needed for the 3d printer. In my case the Ender-3. The firmware can be found on the manufacturers website. Mine is here. We’re gonna go with the factory firmware.

[!NOTE]
You need to put the URL in quotes since the geniuses over at Creality decided to use spaces in the filename. Or insert %20

    $ wget "https://file2-cdn.creality.com/file/b7da70b1c1352a5ca1eb40b83e7e3c0e/Ender-3  Marlin2.0.6 Factory firmware.zip"

2. Unzip the file

    $ unzip "Ender-3  Marlin2.0.6 Factory firmware.zip"

3. Mount and copy to SD Card

    $ sudo mount /dev/sd* /mnt
    # For some reason there are 2 spaces between Ender-3__Marlin* (Because China)
    $ sudo cp "Downloads/Ender-3  Marlin2.0.6 Factory firmware
Ender-3Marlin2.0.6HW4.2.2.bin" /mnt
    $ sudo umount /dev/sd*

4. Insert the card into the 3d printer, and turn it on. The printer will auto detect the .bin file, and install the firmware.

5. Turn off the printer, remove the SD Card, and turn the printer back on to ensure the firmware is installed correctly.

6. For a beginner test print, we will use this website as our slicer program. I used this XYZ 20mm Calibration Cube as a test. Download the .stl.

7. Open the webpage above. Hover over files and click import. Hover over start click slice, then export. You should get a .gcode file.

8. Mount the SD Card again. Remove the .bin file. Copy the .gcode file to the SD Card. Unmount the SD Card

    $ sudo mount /dev/sd* /mnt
    $ sudo rm /mnt/*
    $ sudo cp ~/Downloads/*.gcode /mnt
    $ sudo umount /dev/sd*

9. Insert the SD Card into the printer. Level the bed, as explained here.

10. Select Print from TF Card on the printer. It will start the print. Watch the first few layers for inconsistencies, and either adjust or stop the print and re-level the bed.

9.5.1.3 Observations & Notes

• I printed the bottom half of RPi case. The spacers are messy, and it’s stringy.
• I’d like to build a server rack.

9.5.1.4 Problems / Challenges

• On the first test prints, the first layers were turning out fine. But as it went up it would make a loud knocking sound, and print would start to run off to the side. This told me the z-axis was off. Sure enough the tension screws holding the rod in place were so lose they were almost falling out. I tightened the screws and checked to make sure it was center. it was about 2 degrees off center. I adjusted to make it plumb, and each print was fine after that.

9.5.1.5 Next Actions

• Learn to make minor adjustments
• Print something more advanced
• Learn Blender and Slic3r.

9.5.2 2025-11-14

← Previous | Next →

9.5.2.1 Summary

Example: “Tested SAS HBA with breakout cables — confirmed all four drives detected.”

9.5.2.2 Steps Taken

1. Installed HBA in test PC.
   
2. Connected SAS-to-SATA cables.
   
3. Verified detection in lsblk.

9.5.2.3 Observations & Notes

• Breakout cable pin mismatch caused first detection failure.
  
• Older firmware on HBA required flashing to IT mode.

9.5.2.4 Problems / Challenges

• Need better airflow — drives running hot.

9.5.2.5 Next Actions

• Order fan shroud.
  
• Test with mixed SAS/SATA drives.

9.5.3 2025-08-14

← Previous | Next →

(Continue adding sections for each workday or session)

9.6 Final Technical Report

9.6.1 Project Summary

[Brief recap of what the project is and its purpose]

9.6.2 Development Process

[How the project was developed step-by-step]

9.6.3 Features Implemented

[List of final features and modules]

9.6.4 Technical Specifications

[Full specs, APIs, protocols used]

9.6.5 Testing & Validation

[Testing approach, tools used, and results]

9.6.6 Lessons Learned

[Key takeaways and improvements for next time]

9.6.7 Future Work

[Potential next versions, enhancements, or research]

9.6.8 Appendices

• https://reprap.org/wiki/RepRap
• https://www.thingiverse.com/thing:1278865
• https://www.crealitycloud.com/downloads/firmware/ender-series/ender-3
• https://www.unixmen.com/3d-printing-arch-linux/
• https://3dsolved.com/ender-3-how-to-level-the-bed/
• https://www.instructables.com/G-code/
• https://3dgo.app/slicer

License: “All Rights Reserved”
Schema: technical
Version: 0.1.1
Branding: Mindmap

10 Project PADS

10.1 Project Proposal

10.1.1 Project Title

PADS (Personal Assistant and Deployment System)

10.1.2 Author(s)

Joe Corso

10.1.3 Date

2023-06-05

10.1.4 Problem Statement

The initiation for the project comes from the need to organize, consolidate, maintain, deploy, and automate coding libraries, web apps, and development environments in to a clear, thoughtful, and easy to understand manner.

10.1.5 Objectives

• Provide an extensible Bash and Python framework for system automation.
• Support creation, management, and lifecycle operations of Python projects.
• Automate documentation extraction and rendering through the paddocs subsystem.
• Prepare the architecture for future integration with large language models (LLMs).
• Ensure modularity and portability with clear directory and configuration structures.
• Facilitate secure management of secrets and runtime logs.

10.1.6 Scope

• System automation
• Web app deployment
• Project management
• Self-documenting code

10.1.7 Benefits

By consolidating development, deployment, and documentation tasks into a cohesive ecosystem, PADS empowers users to increase productivity, reduce manual overhead, and maintain high-quality, reproducible workflows.

• Comprehensive integration from system tasks to documentation.
• Modular design allows targeted improvements and maintenance.
• Ready for AI-enhanced workflows with planned LLM support.
• Portable and reproducible across Linux environments.

10.1.8 Risks & Challenges

• NA

10.1.9 Resources Needed

• NA

10.2 Project Overview

10.2.1 Purpose

PADS is a modular, shell-based automation and project management system designed to streamline personal development workflows and infrastructure deployment. It provides a unified command-line interface to manage system-level tasks, Python project scaffolding, documentation generation, and utility tools—all integrated to support reproducibility, scalability, and maintainability.

10.2.2 Background

As a sole developer, it can be difficult to manage multiple projects, and each code snippet. This project was built from the need to have a certain “personal assistant”, which can handle the manual task of building, and maintaining a business infrastructure.

10.2.3 Overview

PADS is divided into modules. Each module maintains it own logic, and documentation. They are grouped by task. Each module has it’s own binary file, and source code directory within the pads directory.

10.2.4 Key Features

• System Automation: Easily execute and schedule OS-level maintenance tasks such as package updates and system monitoring.
• Project Management: Simplify creation, starting, stopping, and deletion of Python-based projects like Flask apps or Pygame games.
• Self-Documenting Framework: Automatically generate comprehensive, versioned documentation from code and configuration using the paddocs subsystem.
• LLM Integration Ready: Designed to incorporate large language models for intelligent code assistance, documentation augmentation, and prompt-driven workflows.
• Secure and Modular Design: Isolates configuration, logs, source code, and secrets to enable robust, secure operations and seamless upgrades.
• Cross-Platform and Portable: Built primarily in Bash and Python, PADS runs on Linux-based systems with minimal dependencies and supports easy installation and migration.

10.2.5 Target Audience

• Self-employed ecommerce business owners.

10.2.6 Expected Impact

Rapid deploment, and low maintainence of an ecommerce business.

10.3 Design Report

10.3.1 Architecture Overview

PADS is organized into four main modules:

• sys: Handles OS-level automation, such as package updates, log management, and environment setup.
• proj: Manages Python project lifecycles, including project creation, start, stop, and removal.
• paddocs: A documentation system that extracts inline docstrings and comments, then renders them into multiple formats (HTML, PDF, Markdown, man pages).
• tools: Miscellaneous utilities that support workflows like network scanning, monitoring, or custom scripts.

10.3.2 Technology Stack

• Git server via git-shell or gitea
• Documentation served via paddocs-generated HTML
• Network tools (ping, traceroute, nmap, etc.)
• Remote backup target via rsync or restic
• Flask/Python app testing for local development
• Jellyfin for media

10.3.3 Data Flow

Input command -> process logic -> Output
                                                         -> run LLM -> Output
pads -> process which command to use -> process OPT/ARGS -> pass command to module -> Output
                                                         -> build env -> Output

paddocs ->

proj ->

sys ->

tools ->

10.3.4 Directory Structure

The PADS project uses a clear directory hierarchy:

pads/
├── sys/ # System-level scripts
├── proj/ # Python project generators and managers
├── paddocs/ # Documentation system source and config
│ ├── src/
│ ├── config/
│ ├── includes/
│ ├── manuscript/
│ ├── output/
│ └── metadata.yaml
├── tools/ # Helper scripts and utilities
├── models/ # LLM prompts, outputs, and evaluation
├── etc/ # Configuration files
├── var/ # Logs and runtime files
├── install/ # Installation and uninstallation scripts
└── tests/ # Unit and integration tests

10.3.5 UI/UX Design

Built in configs for Qtile, KDE Plasma, Arch Linux
Built in Conky Panels showing system performance, mounted devices, etc.
PADS integrates a prompt command:
- located at $PADS_DIR/etc/prompt_command.sh

    promptCommand(){
      local code=$?
      blue="\[$(tput setaf 4)$(tput bold)\]"
      green="\[$(tput setaf 2)$(tput bold)\]"
      red="\[$(tput setaf 1)$(tput bold)\]"
      yellow="\[$(tput setaf 227)$(tput bold)\]"
      orange="\[$(tput setaf 208)$(tput bold)\]"
      grey="\[$(tput setaf 240)$(tput bold)\]"
      r="\[$(tput sgr0)\]"
      bg=${grey}
      ve=${grey}
      f=${grey}
      nx=${grey}
      git=${grey}
      [[ $PWD =~ "git" ]] && git=${orange}
      [[ -n $VIRTUAL_ENV ]] && ve=${orange}
      PS1="[ ${git} ${r} ${ve}VE${r} ${blue}\u@\h \W${r} ] \$ "
    }

PADS has it’s own set of logging, and error reporting using signal traps: - located at: \$PADS_DIR/etc/pads.sig

    msg(){
      local code=$?
      [[ ${code} -eq 0 ]] && printf "[ ${grey}INFO${r} ] :: ${1}\n"
    }

    hup_script(){
      notify-send "PADS" "Bye"
    }
    err_script(){
      local code=$?
      printf "[$code]$red ERROR:${BASH_SOURCE##*/}:${FUNCNAME[0]}:$r ${0##*/}.${mod}.$BASH_LINENO:$BASH_COMMAND\n"
      return $code
    }
    quit_script(){
      printf "Quitting...\n"
      exit 1
    }
    interrupt_script(){
      printf "\n^C\n"
      [[ -f ${lock} ]] && echo "rm lock" && rm $lock
      exit 130
    }

    terminate_script(){
      notify-send "Terminated"
      killall $!
    }
    exit_script(){
      code=$?
      # Code goes here
      exit $code
    }

10.3.6 Security Considerations

• Secrets are stored separately and encrypted in vaults.
• Logs are rotated and separated by module to facilitate auditing.
• The modular structure minimizes risk by isolating critical scripts.
• Secrets and environment variables managed securely via configuration files and optional encrypted vaults.
• Log files and runtime data separated into var/ for easy rotation and monitoring.
• .env and pads.conf allow environment-specific overrides without modifying source code.

10.3.7 Scalability Plan

• Add Pi-hole, local DNS or DHCP
• Integrate ZeroTier or Tailscale for remote VPN
• Deploy model evaluation or inference client
• Expand with external SSD, NAS, or other SBCs

10.4 Technical Report

10.4.1 Introduction

PADS is a modular Bash and Python-based automation system designed to manage personal projects, system tasks, documentation, and integration with large language models (LLMs). It aims to provide a cohesive, reproducible workflow for developers who require both system-level controls and project-level automation.

10.4.2 Methodology

10.4.2.1 Documentation Subsystem (paddocs)

• Extracts documentation from Bash comments and Python docstrings.
• Supports citation styles and templating with Pandoc.
• Organizes content into structured manuscripts (technical reports, manuals, tutorials, blogs).
• Produces multiple output formats (HTML, PDF, man pages).
• Uses metadata.yaml to store document-wide settings.

10.4.2.2 LLM Integration

• Stores prompt templates, configurations, and test evaluations under models/.
• Designed for offline or remote LLM backends.
• Supports session logging and output archival for reproducibility.

10.4.3 Implementation Details

• The system uses trap commands to log script execution and errors.
• Documentation extraction leverages Python’s ast module and Bash comment parsing.
• The project follows Unix conventions for configuration (etc/), runtime data (var/), and source code (src/ within modules).
• Symlinks in bin/ provide easy CLI access.
• Environment variables and secrets are isolated via .env and vault solutions.
• Built in project management assists in deploying local web services.

10.4.4 Results

PADS is a versatile platform combining automation, project management, documentation, and AI-readiness. It enables developers to streamline complex workflows within a structured, secure, and extensible environment.

10.4.5 Analysis

• Unified toolset simplifies multi-domain workflows.
• Modular design eases maintenance and extension.
• Documentation tightly integrated with code for accuracy and currency.
• Prepares groundwork for AI-enhanced development.

10.4.6 Challenges & Limitations

• LLM integration currently requires manual setup.
• Documentation rebuilds are not automatic but scripted.
• Vault encryption depends on external tooling.

10.4.7 Recommendations

• CLI dashboard for managing modules and workflows.
• Git hook integration for automatic documentation rebuilds.
• GUI front-end for less technical users.
• Enhanced LLM agents for assisted coding and documentation.
• Cross-platform support improvements.

10.4.8 Conclusion

PADS is a comprehensive, extensible system designed to automate and streamline development and deployment workflows. By combining scripting, documentation, and AI readiness, it positions itself as a future-proof platform for personal and small team project management.

10.4.9 References

NA

10.5 Final Technical Report

10.5.1 Project Summary

PADS is a modular, command-line driven automation and project management system aimed at personal developers and small teams. It integrates system-level operations, project scaffolding, documentation generation, and tooling under a unified interface to simplify complex workflows.

10.5.2 Features Implemented

• pads
• paddocs
• sys
• proj
• tools
• signal traps
• LLM’s
• infastructure deployment

10.5.3 Future Work

• More robust infastructure deployment

Template generated by ChatGPT
Documentation generated by PADDOCS
Compendium section: 10-docs
Title: Project PADS
Author: Joe Corso
Created: 2022-05-04
Updated: 2025-10-26
Tags: automation, bash
Status: [ Draft / Final / Reviewed ]
Template:
- 00-project-proposal.md
- 01-project-overview.md
- 02-design-report.md
- 03-technical-report.md
- 04-research-log.md
- 05-final-report.md
License: “All Rights Reserved”
Schema: technical
Version: 0.1.1
Branding: Operation Mindmap

10.6 Paddocs

This manual is for PADDOCS (1.1.0, 2025-10-25) A module which self-generates documentation

10.6.1 Introduction

Paddocs is a module for PADS which self generates documentation from code into a technical manual, blog, info, and man pages. This documentation was generated using the same library. You can generate the book layout into the ~/dev/pads/paddocs/ directory. Write the documentation within the programs files using the headers outlined in Notes. Build the documentation with -b, then generate the docs with -g. You can also use paddocs to generate report templates, metadata for the book, covers, bibliography info. etc.

• Repository: https://github.com/padsRepo/pads

• Blog: https://padsrepo.github.io/pads/

• Docs: https://github.com/padsRepo/pads/wiki

10.6.1.1 Before you start

Before you begin, make sure you meet these prerequisites:

• Bash >= 5.2
• Pandoc >= 3.4
• Texlive >= 2025.2-2
• Texlive-bibtexextra >= 2025.2-2
• Texlive-context >= 2025.2-2
• Texlive-fontsextra >= 2025.2-2
• Texlive-fontsrecommended >= 2025.2-2
• Texlive-fontutils >= 2025.2-2
• Texlive-formatsextra >= 2025.2-2
• Texlive-latex >= 2025.2-2
• Texlive-latexextra >= 2025.2-2
• Texlive-latexrecommended >= 2025.2-2
• Texlive-luatex >= 2025.2-2
• TTF-Hack
• TTF-Nerd-Fonts-Symbols

10.6.1.2 Get started

1. Download:

    $ git clone https://github.com/padsRepo/paddocs

2. Install:

    $ makepkg -si

10.6.1.3 What’s next

1. Build the book:

   $ paddocs -b book && paddocs -b metadata

2. Write your inline-documentation using the headers outlined in Notes
   • You don’t have to use all of them
3. Make a directory same as your command name under manuscript/<sectionName>/<cmd>
4. Copy the report schema you need from /assets/schemas to /manuscript/<sectionName>/
5. Generate your documentation:

   $ paddocs -c <cmd> -l <lang> -b doc && paddocs -g book html

6. View it in the browser:

   $ paddocs -s
   $ http://127.0.0.1:8000

10.6.2 Synopsis

<cmd> -[<argument>] [<name>]
paddocs -[b:,c:,g:,l:,s,v,h] [<name>]

10.6.3 Options

-b <name>                        Build <name> to manuscript/
                                 <type> is one of: book, metadata, readme, license, doc, man
-c <name>                        Command to generate docs for
-g <type> <prefix> <sectionName> Generate <name> to output/
                                 <type> is one of: markdown, html, pdf, section, chapter, man
-l <name>                        Coding language to use for the code block.
-s                               Run python -m http.server and exit
-v                               Show Version
-h                               Show Usage

10.6.4 Modules / Components

10.6.5 API Reference

10.6.6 Examples

paddocs -h

Show the help menu and exit

paddocs -v

Show the version and exit

paddocs -b book

Build the skeleton project for paddocs to \${base_dir}/paddocs/

paddocs -c paddocs -l bash -b docs

Build the technical manual for paddocs into the paddocs/manuscript/10-docs/\<projDir\> directory. This is if you need more of a report. If you want the manpage use man instead.

paddocs -c paddocs -l bash -b man

Build the man page for paddocs into the paddocs/manuscript/11-manual/\<cmd\>.md directory.

paddocs -g book pdf

Generate a PDF compendium of the entire manuscript/ directory to output/compendium.pdf

paddocs -g book html

Generate a PDF compendium of the entire manuscript/ directory to output/compendium.html

10.6.7 Configuration

10.6.7.1 Exit Status:

10.6.7.2 Environment Variables:

10.6.7.3 Config Files/Directories:

10.6.8 Advanced Usage

paddocs -s

Run a http.server to view the files in a web browser. Search the url in your browser: http://127.0.0.1:8000

paddocs -c paddocs -l bash -b man && paddocs -g man -c paddocs

Build the man page for paddocs into the paddocs/manuscript/11-manual/\<cmd\>.md directory. Then generate a man page for paddocs. This will automatically mv the tar.gz file to /usr/share/man/man1. After it’s complete you will be able to type man <name> for the man page.

paddocs -c interlink -l python -b doc && paddocs -g section html interlink

Build the technical manual for a python library. Then generate the section for it to /output/section/<cmd>.

10.6.9 Troubleshooting

1. turn it off and on again
2. blow on it
3. say 3 hail mary’s

10.6.10 Contributing

1. Fork the repo
2. Create a feature branch (git checkout -b feature-name)
3. Commit changes (git commit -m "Add feature")
4. Push branch (git push origin feature-name)
5. Open a Pull Request

10.6.11 License

MIT License

Copyright (c) 2022 Joe Corso

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.

10.6.12 History

• 2025-04-08 Project Paddocs was created
• 2025-04-25 Added Source Code block to templates.
• 2025-05-28
  • Added buildbook, genreadme, genlicense, gendocs, genman, genhtml, genpdf, genall functions
  • Divided logic into build.sh and generate.sh
  • Created section, chapter, man
• 2025-06-19
  • Created python module to parse python code
• 2025-07-13
  • Refractored generate.sh
  • Refractored build.sh
  • Changed $quickie to $readme
• 2025-07-15
  • Refractored vars.sh to parse.sh
  • Combined python and bash module into parse.sh/{parseBash,parsePython}
  • Added -s flag for built in web server python -m http.server 8088
• 2025-08-08
  • Added responsive.css
  • Refractored generate.sh
• 2025-08-12
  • Reworked the book structure
• 2025-08-14
  • Added module, api, advanced, troubleshoot, contributing headers
  • Integrated programming-manual.md template into doc() function
• 2025-11-08
  • Added a resume category.

10.6.13 Notes

• The readme headers must all have spaces after the ## to render the markdown properly. Ex: ##_ NOT ##. Or they can use new lines for proper formatting.
• Headers:
• Shell:
  • title
  • subtitle
  • brief
  • desc
  • author
  • email
  • created
  • repoURL
  • docsURL
  • blogURL
  • version
  • copyright
  • end copyright
  • lic
  • synopsis
  • syntax
  • usageOpts (This is generated from the usage() function)
  • exit
  • end exit
  • env
  • end env
  • file
  • end file
  • history
  • end history
  • note
  • end note
  • example
  • end example
  • seealso
  • sourcecode
  • readme
  • end readme
  • modules
  • end modules
  • api
  • end api
  • advanced
  • end advanced
  • troubleshoot
  • end troubleshoot
  • contributing
  • end contributing
• Python:
  • __doc__
  • __version__
  • __author__
  • __date__
  • __updated__
  • __copyright__
  • __license__
  • __email__
  • __status__
  • __description__
  • Google Style Docstrings

10.6.14 See Also

man paddocs, info pads

10.6.15 Source Code

title="Paddocs"
subtitle="Self-Generating Documentation Module"
version="1.1.0"
OPTSTRING="b:,c:,g:,l:,s,v,h"
synopsis="<cmd> -[<argument>] [<name>]"
syntax="${0##*/} -[${OPTSTRING}] [<name>]"
base_dir="$(dirname "$(readlink -f "${0%/*}")")"

description(){
cat << EOF
* ${title}
* ${subtitle}

EOF
}

usage(){
cat << EOF
Synopsis: $synopsis
Syntax: $syntax
Usage:
  -b <name>                        Build <name> to manuscript/
                                   <type> is one of: book, metadata, readme, license, doc, man
  -c <name>                        Command to generate docs for
  -g <type> <prefix> <sectionName> Generate <name> to output/
                                   <type> is one of: markdown, html, pdf, section, chapter, man
  -l <name>                        Coding language to use for the code block.
  -s                               Run python -m http.server and exit
  -v                               Show Version
  -h                               Show Usage
Ex: paddocs -c pads -l bash -b doc | paddocs -c paddocs -l bash -b man | paddocs -c interlink -l python -b doc && paddocs -g section html interlink
See also: man paddocs, info pads
EOF
}

manual(){
description
usage
}

while getopts ${OPTSTRING} mod; do
case ${mod} in
  b) build=${OPTARG};;
  c) cmd=${OPTARG};;
  g) type=${OPTARG}; prefix=${3}; sectionName=${4};;
  l) lang=${OPTARG};;
  s) server=True;;
  v) echo "${version}"; exit;;
  h) usage; exit;;
  ?) echo " * ${0##*/} -h for help"; exit 2;;
  *) echo "K18 Error"; exit 2;;
esac
done
[[ $# -eq 0 ]] && manual && exit
. "${base_dir}/etc/paulBunyan.sh"
. "${base_dir}/src/paddocs/src/parse.sh"

cd $base_dir/src/paddocs

if [[ ${lang} == "bash" ]]; then
  parseBash
elif [[ ${lang} == "python" ]]; then
  parsePython && [[ $? -eq 0 ]] && INFO "\nBuild: ${build} \nCMD: ${cmd} \nFile: file:/\${saveDir}/10-${cmd}.md \n" && exit
elif [[ -n $server ]]; then
  python -m http.server 8000 &
fi  

[[ -n ${build} ]] && . "$base_dir/src/paddocs/src/build.sh" && $build && [[ $? -eq 0 ]] && INFO "\nBuild: ${build} \nCMD: ${cmd} \nFile: file://${savePath} \n" && exit
[[ -n ${type} ]] && . "${base_dir}/src/paddocs/src/generate.sh" && [[ $? -eq 0 ]] && INFO "\nGenerate: file://${save_dir}\n" && exit 0

Template generated by ChatGPT
Documentation generated by PADDOCS
Compendium section: 10-docs
Title: Paddocs
Author: Joe Corso
Tags: [self-generate, documentation, manual, bash]
Status: [ Draft / Final / Reviewed ]
Post ID: paddocs.md
Template: programming-manual.md
License: All Rights Reserved
Schema: manuals
Version: 1.1.0

10.7 PADS

This manual is for PADS (1.1.0, 2025-10-22) Personal Assistant and Deployment System

10.7.1 Introduction

PADS is a shell-based automation framework designed to simplify system tasks and project scaffolding through concise command-line flags. PADS serves as a wrapper around common system and development tasks, providing a more streamlined and user-friendly interface. PADS is designed to support the VCS, Workflow, and development of [Project Starship].

• Repository: https://github.com/padsRepo/pads

• Blog: https://padsrepo.github.io/pads/

• Docs: https://github.com/padsRepo/pads/wiki

10.7.1.1 Before you start

Before you begin, make sure you meet these prerequisites:

• Bash >= 5.2

10.7.1.2 Get started

1. Download: git clone git+ssh://pi@rpi400.local/srv/repo/git/pads.git

2. Install: makepkg -si

3. Add to /etc/pacman.conf:

[datasphere]
SigLevel = Optional TrustAll
Server = http://rpi400.local/db/core

[multiverse]
SigLevel = Optional TrustAll
Server = http://rpi400.local/db/extra

10.7.1.3 What’s next

10.7.2 Synopsis

<cmd> -[<module>] -[<argument>] -[<option>] [name...]
pads -[L:,B:,S:,P:,R:,T:,x,v,h] -[arg]

10.7.3 Options

-B <name> <subtitle> Build new binary command
-D <name> Build skeleton directory for given project
-L  Chat with PADS LLM
-S [-h] System Module
-P [-h] Project Module
-R [-h] Utilities Module
-T [-h] Test Module
-x      Set -x
-v      Show Version
-h      Show Usage

10.7.4 Modules / Components

10.7.5 API Reference

10.7.6 Examples

pads -Pfm project && pads -Pfs project

In this example we make and start a Flask project named project.

pads -Su

In this example we update the system and enter the password.

pads -Su neofetch ...

In this example we install as many packages as we want seperated by spaces. You can use pacman or yay.

10.7.7 Configuration

10.7.7.1 Exit Status:

10.7.7.2 Environment Variables:

10.7.7.3 Config Files/Directories:

10.7.8 Advanced Usage

paddocs do something

This will make the pc…

paddocs do something

This will make the pc…

paddocs do something

This will make the pc…

paddocs do something

This will make the pc…

10.7.9 Troubleshooting

1. turn it off and on again
2. blow on it
3. say 3 hail mary’s

10.7.10 Contributing

1. Fork the repo
2. Create a feature branch (git checkout -b feature-name)
3. Commit changes (git commit -m "Add feature")
4. Push branch (git push origin feature-name)
5. Open a Pull Request

10.7.11 License

MIT License

Copyright (c) 2022 Joe Corso

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.

10.7.12 History

• PADS is General Purpose Artificial Intelligence designed to carry out every day business tasks. It’s purpose is to provide book keeping, employee timesheets, client tracking, automation, etc. It can do double entry accounting for hybrid manufacturing companies. None of the data is loaded as Environment Variables, so your interaction with PADS is between you and it. It’s original purpose was to serve as a website, with a relational historical database. Work on this project began in Python using the Django Framework on June 23, 2021 at 5:30pm. The accounting database first came online Oct. 13th, 2021 at 11:48pm. The Bash Syntax was first created by Joe Corso on May 4th, 2022. It was previously codenamed Project Eniac, to pay homage to the original project of the same name.
• Work began on an Arch Linux distro
• The original man page was created 2023-09-08
• Flask Project for Accounting was created
• Flask API was created
• Started using Qtile (switched from XFCE4).
• Created info page
• Started using pandoc and mkdocs for self-documenting code
• Started creating my own self-generating code, named paddocs.
• Separated each module into it’s own commands within the PADS Project.
• Started documenting my work as I go.
• Organized my github to have a wiki, blog, and repo for source code.
• Rewrite the directory structure for the final time.
• Added .padsrc to main project folder for a file to search.
• Added -B flag
• Developed Datasphere. A project for a personal repository. This lib is now a going to move in the direction of a project/package manager for the repository.
• 2025-10-22
  • Merged/Changed proj -> /src/pads/project_manager.sh
  • Edited project_manager.sh to manage git repo, as opposed to templates
  • Merged/Changed sys -> `/src/pads/system_manager.sh
• 2026-04-21
  • Changed everything back to their respective commands, because I can never decide. So hopefully this is the last time.

10.7.13 Notes

• Logic files which needs getopts will be created as a new binary command in /$base_dir/bin
• All documentation is now within the respective code. It used to all be jammed in here.
• The PADS command has evolved into a set of libraries which work interchangeably.

10.7.14 See Also

sys, proj, tools, paddocs, man pads, info pads

10.7.15 Source Code

title="PADS"
subtitle="Personal Assistant and Deployment System"
version="1.1.1"
OPTSTRING="L:,B:,S:,P:,R:,T:,x,v,h"
synopsis="<cmd> -[<module>] -[<argument>] -[<option>] [name...]"
syntax="${0##*/} -[${OPTSTRING}] -[arg]"
base_dir="$(dirname "$(readlink -f "${0%/*}")")"
. "${base_dir}/etc/paulBunyan.sh"
description(){
cat << EOF
* ${title}
* ${subtitle}
EOF
}
usage(){
cat << EOF
Synopsis: $synopsis
Syntax: $syntax
Usage:
  -B <name> <subtitle> Build new binary command
  -D <name> Build skeleton directory for given project
  -L ${opts} Chat with PADS LLM
  -S [-h] System Module
  -P [-h] Project Module
  -R [-h] Utilities Module
  -T [-h] Test Module
  -x      Set -x
  -v      Show Version
  -h      Show Usage
Ex: pads -Pfs <flaskproject> | pads -Su nano neofetch firefox
See also: sys, proj, tools, man pads, info pads
EOF
}
manual(){
description
usage
}
while getopts ${OPTSTRING} mod; do
mod=${mod}
case ${mod} in
  x) set -$mod;;
  B) . "${base_dir}/pads/build_cmd.sh"; exit;;
  D) . "${base_dir}/pads/build_dir.sh"; exit;;
  S) cmd="sysmgr"; param=${OPTARG};;
  P) cmd="projmgr"; param=${OPTARG};;
  R) param=${OPTARG}; cmd="handyman";;
  T)
    param=${OPTARG}; exec $base_dir/bin/sys -$param;
    ;;
  v) echo "${version}"; exit;;
  h) usage; exit;;
  ?) echo " * ${0##*/} -h for help"; exit 2;;
  *) echo "K18 Error"; exit 2;;
esac
done
[[ $# -eq 0 ]] && manual && exit
${base_dir}/bin/${cmd} -${param} ${@:2}

Template generated by ChatGPT
Documentation generated by PADDOCS
Compendium section: 10-docs
Title: PADS
Author: Joe Corso
Tags: [self-generate, documentation, manual, bash]
Status: [ Draft / Final / Reviewed ]
Post ID: pads.md
Template: programming-manual.md
License: All Rights Reserved
Schema: manuals
Version: 1.1.1

10.8 (P)roject Module

This manual is for PROJ (0.0.5, 2025-02-26) A module made for PADS

10.8.1 Introduction

The purpose of this module is to automate project management on your machine. It should build, start, delete and manage the a virual env, projects from differents languages and web frameworks.

• Repository: https://github.com/padsRepo/pads

• Blog: https://padsrepo.github.io/pads/

• Docs: https://github.com/padsRepo/pads/wiki

10.8.2 Synopsis

<cmd> -[<argument>] -[<option>] [name...]
proj -[p:,f:,g:,h,v] -[m,s,d] <name>

10.8.3 Options

  -p -[m,s,d] <name> Manage a python project
-f -[m,s,d] <name> Manage a flask project
-g -[m,s,d] <name> Manage a pygame project
-h Show usage
-v Show version

10.8.4 Modules / Components

10.8.5 API Reference

10.8.6 Examples

proj -fm project && proj -fs project

In this example we make and start a Flask project named project.

proj -d project

In this example we the project named project.

proj -e flask

In this example we manage the virtual environment name flask.

10.8.7 Configuration

Exit Status:

Environment Variables:

Config Files/Directories:

10.8.8 Advanced Usage

10.8.9 Troubleshooting

10.8.10 Contributing

10.8.11 License

MIT License

Copyright (c) 2022 Joe Corso

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.

10.8.12 History

• 2025-04-10 This module became it’s own command
• 2025-04-10 Added self generating documentation

10.8.13 Notes

• This cmd needs to do more things managing virtual envs

10.8.14 See Also

info pads

10.8.15 Source Code

module="(P)roject Module"
description="For managing projects that are not bash"
version="0.0.5"
author="Joe Corso (https://www.joecorso.com)"
created="$(date -d '20230605')"
docs="https://github.com/padsRepo"
license="MIT License"
OPTSTRING="p:,f:,g:,h,v"
options="-[m,s,d] <name>"
synopsis="<cmd> -[<argument>] -[<option>] [name...]"
syntax="${0##*/} -[${OPTSTRING}] ${options}"
base_dir="$(dirname "$(readlink -f "${0%/*}")")"
description(){
cat << EOF
* ${module}
* ${description}

EOF
}
usage(){
cat << EOF
Synopsis: $synopsis
Syntax: $syntax
Usage:
  -p $options Manage a python project
  -f $options Manage a flask project
  -g $options Manage a pygame project
  -h Show usage
  -v Show version
Ex: ${0##*/} -r neofetch | ${0##*/} -u nano neofetch firefox
See also: man ${0##*/}, man pads, info pads, pads
Author: $author
Version: $version
Created: $created
$license
EOF
}
manual(){
description
usage
}
while getopts $OPTSTRING arg; do
arg=$arg
opt=${OPTARG#*-}
name=${3:-$2}
case $arg in
  p) 
    project_dir="${BIN_DIR}/lib/${proj}"
    template_dir="python"
    echo "This is disabled for now line: $LINENO module: $module_dir/proj/proj"
    exit
    ;;
  f) 
    project_dir="${HOME}/srv/${proj:-$name}"
    template_dir="flask"
    virtualenv_dir="${HOME}/env/flask"
    ;;
  g) 
    project_dir="${HOME}/games/${proj}"
    template_dir="game"
    virtualenv_dir="${HOME}/env/games"
    ;;
  h) manual; exit;;
  v) echo $version; exit;;
  *) echo " * ${0##*/} -${mod}h for help"; exit 2;;
esac
done
[[ $# -eq 0 ]] && manual  && exit 2
. "${base_dir}/src/proj/parseopts"
${opt}_proj

Template generated by ChatGPT
Documentation generated by PADDOCS
Compendium section: 10-docs
Title: (P)roject Module
Author: Joe Corso
Tags: [self-generate, documentation, manual, bash]
Status: [ Draft / Final / Reviewed ]
Post ID: proj.md
Template: programming-manual.md
License: All Rights Reserved
Schema: manuals
Version: 0.0.5

10.9 (S)ystem Module

This manual is for SYS (0.0.5, 2025-02-26) A module made for PADS

10.9.1 Introduction

The purpose of this module is to automate system commands on your machine. It should be able to build your DE, WM, configs, install the OS, set up your bashrc, backup your machine, etc.

• Repository: https://github.com/padsRepo/pads

• Blog: https://padsrepo.github.io/pads/

• Docs: https://github.com/padsRepo/pads/wiki

10.9.2 Synopsis

<cmd> -[<argument>] -[<option>] [name...]
sys -[b,u,i,l,d,r:,m,s,h,v] [name...]

10.9.3 Options

  -b           Backup System
-u [name...] Update machine. Supply name of package to install.
-i           Update pads' info page
-l           List packages on this machine
-d           Update pads' man page
-r <name...> Remove supplied packages
-m           Set up mariadb
-s           Show system information
-h           Show help
-v           Show version

10.9.4 Modules / Components

10.9.5 API Reference

10.9.6 Examples

sys -m

In this example we set up mariadb on our system, including the secure-install, and generating a user and password.

sys -u

In this example we update the system and enter the password.

sys -u neofetch ranger btop ...

In this example we install as many packages as we want seperated by spaces.

You can use pacman or yay.

10.9.7 Configuration

Exit Status:

Environment Variables:

Config Files/Directories:

10.9.8 Advanced Usage

10.9.9 Troubleshooting

10.9.10 Contributing

10.9.11 License

MIT License

Copyright (c) 2022 Joe Corso

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.

10.9.12 History

• 2025-04-10 This module became it’s own command
• 2025-04-10 Added self generating documentation

10.9.13 Notes

• This cmd needs to do more of things I describe.

10.9.14 See Also

info pads

10.9.15 Source Code

module="(S)ystem Module"
description="Running system commands on your machine."
version="0.0.5"
author="Joe Corso (https://www.joecorso.com)"
created="$(date -d '20230605')"
docs="https://github.com/padsRepo"
license="MIT License"
packages="${@:2}"
OPTSTRING="b,u,i,l,d,r:,m,s,h,v"
synopsis="<cmd> -[<argument>] -[<option>] [name...]"
syntax="${0##*/} -[$OPTSTRING] [name...]"
base_dir="${PADS_DIR}/sys"
. "${PADS_DIR}/etc/pads.sig"
description(){
cat << EOF
* ${module}
* ${description}

EOF
}
usage(){
cat << EOF
Synopsis: ${synopsis}
Syntax: ${syntax}
Usage:
  -b           Backup System
  -u [name...] Update machine. Supply name of package to install.
  -i           Update pads' info page
  -l           List packages on this machine
  -d           Update pads' man page
  -r <name...> Remove supplied packages
  -m           Set up mariadb
  -s           Show system information
  -h           Show help
  -v           Show version
Ex: ${0##*/} -r neofetch | ${0##*/} -u nano neofetch firefox
See also: man ${0##*/}, man pads, info pads, pads
EOF
}

manual(){
description
usage
}

while getopts $OPTSTRING name; do
arg=$name
case $arg in
  b) function="backup";;
  u) function="update";;
  i) function="updateinfo";;
  l) pacman -Qqen; exit;;
  d) function="updateman";;
  r) sudo pacman -Rcns $packages; exit;;
  m) function="setupmariadb";;
  s) function="sysinfo";;
  h) usage; exit;;
  v) echo "$version"; exit;;
  ?) echo " * ${0##*/} -${mod}${arg}h for help"; exit 2;;
esac
done
[[ -z $arg ]] && manual  && exit
. "${base_dir}/${function}"
[[ $? -eq 0 ]] && msg "Success!" || msg "Failure!"

Template generated by ChatGPT
Documentation generated by PADDOCS
Compendium section: 10-docs
Title: (S)ystem Module
Author: Joe Corso
Tags: [self-generate, documentation, manual, bash]
Status: [ Draft / Final / Reviewed ]
Post ID: sys.md
Template: programming-manual.md
License: All Rights Reserved
Schema: manuals
Version: 0.0.5

10.10 (R)un Module

This manual is for TOOLS (0.0.5, 2025-02-26) A module made for PADS

10.10.1 Introduction

The purpose of this module is to run random scripts on your machine.

• Repository: https://github.com/padsRepo/pads

• Blog: https://padsrepo.github.io/pads/

• Docs: https://github.com/padsRepo/pads/wiki

10.10.2 Synopsis

<cmd> -[<argument>] -[<option>] [name...]
tools -[s,v,h] [name...]

10.10.3 Options

 -s  
   passgen           Generate a random password  
   note              Take a note  
   buildpkg          Build Package to install  
   conkystart        Start Conky panels  
   timer <int>       Start a countdown timer for 3 seconds  
   progress          Show a progress bar  
   resetpath         Reset default $PATH  

-h Show help
-v Show version

10.10.4 Modules / Components

10.10.5 API Reference

10.10.6 Examples

tools -s genpass

In this example we generate a random password.

tools -s timer 10

In this example we start a countdown timer for 10 seconds.

tools -s note

In this example we start the note taking app.

10.10.7 Configuration

Exit Status:

Environment Variables:

Config Files/Directories:

10.10.8 Advanced Usage

10.10.9 Troubleshooting

10.10.10 Contributing

10.10.11 License

MIT License

Copyright (c) 2022 Joe Corso

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.

10.10.12 History

• 2025-04-10 This module became it’s own command

10.10.13 Notes

• I probably dont need this

10.10.14 See Also

info pads

10.10.15 Source Code

module="(R)un Module"
description="Running misc scripts. Good for testing"
version="0.0.3"
author="Joe Corso (https://www.joecorso.com)"
created="$(date -d '20230605')"
docs="https://github.com/padsRepo"
license="MIT License"
packages="${@:2}"
OPTSTRING="s,v,h"
synopsis="<cmd> -[<argument>] -[<option>] [name...]"
syntax="${0##*/} -[$OPTSTRING] [name...]"
base_dir="$(dirname "$(readlink -f "${0%/*}")")"
. "${PADS_DIR}/etc/pads.sig"
description(){
cat << EOF
* ${module}
* ${description}

EOF
}
usage(){
cat << EOF
Synopsis: $synopsis
Syntax: $syntax
Usage:
 -s  
     passgen           Generate a random password  
     note              Take a note  
     buildpkg          Build Package to install  
     conkystart        Start Conky panels  
     timer <int>       Start a countdown timer for 3 seconds  
     progress          Show a progress bar  
     resetpath         Reset default \$PATH  
 -h                    Show help  
 -v                    Show version  
Ex: paddocs -c pads -l bash -nmrwxs | paddocs -c paddocs -l bash -wsxp
See also: man paddocs, info pads
EOF
}
manual(){
description
usage
}
while getopts $OPTSTRING arg; do
opt=${OPTARG}
name=${3:-$2}
case ${arg} in
  s) . "${PADS_DIR}/tools/${name}" $OPTARG; exit;;
  v) echo "$version"; exit;;
  h) manual; exit;;
  *) echo "$OPTARG * ${0##*/} -${mod}h for help"; exit 2;;
esac
done
[[ $# -eq 0 ]] && manual  && exit 2

Template generated by ChatGPT
Documentation generated by PADDOCS
Compendium section: 10-docs
Title: (R)un Module
Author: Joe Corso
Tags: [self-generate, documentation, manual, bash]
Status: [ Draft / Final / Reviewed ]
Post ID: tools.md
Template: programming-manual.md
License: All Rights Reserved
Schema: manuals
Version: 0.0.3

11 Project Datasphere

11.1 Project Proposal

11.1.1 Project Title

Project Datasphere

11.1.2 Author(s)

Joe Corso - Developer, Author

11.1.3 Date

2025-10-03

11.1.4 Problem Statement

As a developer starts to gain experience; naturally, their projects start to grow. They make changes which break systems, they don’t know how to back things up. They don’t understand the need for version control They don’t understand the need for good CI/CD pipelines and workflow through documenting, building, deploying, and maintaining a project. They tend to get stuck in development purgatory when it comes time to decide the scaffolding, styling, and namespaces of a project. They may not understand how to write good comments, or that inline comments can become the documentation for the project. Finally, they have not been a developer long enough to experience catastrophic failures, rebuilding systems, or that they suffer from CRS.

11.1.5 Objectives

To solve the aforementioned issues, we will introduce the concept of CI/CD Pipelines, Semantic Versioning, Workflow, and Style Guides for starting a project. This is not comprehensive, and can be added to as needs change.

We will be plotting out blueprints, that can be used for:

• Automated Pipelines
• Automated Workflows
• Automated Version Control
• Documentation for Pipelines
• Documentation for Workflow
• Documentation for Style Guides

11.1.6 Scope

• System Architecture
• Networking
• CI/CD Pipelines
• Semantic Versioning
• Project Management
• Education
• Critical Applications
• Style Guide
• Scientific Research

11.1.7 Benefits