├── pyproject.toml
├── README.md
├── args.py
├── .gitignore
├── thttp.py
└── djbs.py


/pyproject.toml:
--------------------------------------------------------------------------------
1 | [tool.black]
2 | line-length = 120
3 | 
4 | [tool.isort]
5 | line_length=120
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Django Bootstrap
 2 | 
 3 | _Very much a work in progress_.
 4 | 
 5 | ## Usage
 6 | 
 7 | ```
 8 | python3 djbs.py
 9 | ```
10 | 
11 | You will be prompted to provide an app name, domain and base directory for the project.
12 | 


--------------------------------------------------------------------------------
/args.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | 
 4 | def parse_args(args):
 5 |     result = {
 6 |         a.split("=")[0]: int(a.split("=")[1])
 7 |         if "=" in a and a.split("=")[1].isnumeric()
 8 |         else a.split("=")[1]
 9 |         if "=" in a
10 |         else True
11 |         for a in args
12 |         if "--" in a
13 |     }
14 |     result["[]"] = [a for a in args if not a.startswith("--")]
15 |     return result
16 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ### https://raw.github.com/github/gitignore/96d68766538413194aabd55e3622734cd501e715/Python.gitignore
  2 | 
  3 | # Byte-compiled / optimized / DLL files
  4 | __pycache__/
  5 | *.py[cod]
  6 | *$py.class
  7 | 
  8 | # C extensions
  9 | *.so
 10 | 
 11 | # Distribution / packaging
 12 | .Python
 13 | build/
 14 | develop-eggs/
 15 | dist/
 16 | downloads/
 17 | eggs/
 18 | .eggs/
 19 | lib/
 20 | lib64/
 21 | parts/
 22 | sdist/
 23 | var/
 24 | wheels/
 25 | share/python-wheels/
 26 | *.egg-info/
 27 | .installed.cfg
 28 | *.egg
 29 | MANIFEST
 30 | 
 31 | # PyInstaller
 32 | #  Usually these files are written by a python script from a template
 33 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 34 | *.manifest
 35 | *.spec
 36 | 
 37 | # Installer logs
 38 | pip-log.txt
 39 | pip-delete-this-directory.txt
 40 | 
 41 | # Unit test / coverage reports
 42 | htmlcov/
 43 | .tox/
 44 | .nox/
 45 | .coverage
 46 | .coverage.*
 47 | .cache
 48 | nosetests.xml
 49 | coverage.xml
 50 | *.cover
 51 | *.py,cover
 52 | .hypothesis/
 53 | .pytest_cache/
 54 | cover/
 55 | 
 56 | # Translations
 57 | *.mo
 58 | *.pot
 59 | 
 60 | # Django stuff:
 61 | *.log
 62 | local_settings.py
 63 | db.sqlite3
 64 | db.sqlite3-journal
 65 | 
 66 | # Flask stuff:
 67 | instance/
 68 | .webassets-cache
 69 | 
 70 | # Scrapy stuff:
 71 | .scrapy
 72 | 
 73 | # Sphinx documentation
 74 | docs/_build/
 75 | 
 76 | # PyBuilder
 77 | .pybuilder/
 78 | target/
 79 | 
 80 | # Jupyter Notebook
 81 | .ipynb_checkpoints
 82 | 
 83 | # IPython
 84 | profile_default/
 85 | ipython_config.py
 86 | 
 87 | # pyenv
 88 | #   For a library or package, you might want to ignore these files since the code is
 89 | #   intended to run in multiple environments; otherwise, check them in:
 90 | # .python-version
 91 | 
 92 | # pipenv
 93 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 94 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 95 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 96 | #   install all needed dependencies.
 97 | #Pipfile.lock
 98 | 
 99 | # poetry
100 | #   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
101 | #   This is especially recommended for binary packages to ensure reproducibility, and is more
102 | #   commonly ignored for libraries.
103 | #   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
104 | #poetry.lock
105 | 
106 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
107 | __pypackages__/
108 | 
109 | # Celery stuff
110 | celerybeat-schedule
111 | celerybeat.pid
112 | 
113 | # SageMath parsed files
114 | *.sage.py
115 | 
116 | # Environments
117 | .env
118 | .venv
119 | env/
120 | venv/
121 | ENV/
122 | env.bak/
123 | venv.bak/
124 | 
125 | # Spyder project settings
126 | .spyderproject
127 | .spyproject
128 | 
129 | # Rope project settings
130 | .ropeproject
131 | 
132 | # mkdocs documentation
133 | /site
134 | 
135 | # mypy
136 | .mypy_cache/
137 | .dmypy.json
138 | dmypy.json
139 | 
140 | # Pyre type checker
141 | .pyre/
142 | 
143 | # pytype static type analyzer
144 | .pytype/
145 | 
146 | # Cython debug symbols
147 | cython_debug/
148 | 
149 | # PyCharm
150 | #  JetBrains specific template is maintainted in a separate JetBrains.gitignore that can
151 | #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
152 | #  and can be added to the global gitignore or merged into this file.  For a more nuclear
153 | #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
154 | #.idea/
155 | 
156 | 
157 | 


--------------------------------------------------------------------------------
/thttp.py:
--------------------------------------------------------------------------------
  1 | """
  2 | UNLICENSED
  3 | This is free and unencumbered software released into the public domain.
  4 | 
  5 | https://github.com/sesh/thttp
  6 | """
  7 | 
  8 | import gzip
  9 | import json as json_lib
 10 | import ssl
 11 | from base64 import b64encode
 12 | from collections import namedtuple
 13 | from http.cookiejar import CookieJar
 14 | from urllib.error import HTTPError, URLError
 15 | from urllib.parse import urlencode
 16 | from urllib.request import HTTPCookieProcessor, HTTPRedirectHandler, HTTPSHandler, Request, build_opener
 17 | 
 18 | Response = namedtuple("Response", "request content json status url headers cookiejar")
 19 | 
 20 | 
 21 | class NoRedirect(HTTPRedirectHandler):
 22 |     def redirect_request(self, req, fp, code, msg, headers, newurl):
 23 |         return None
 24 | 
 25 | 
 26 | def request(
 27 |     url,
 28 |     params={},
 29 |     json=None,
 30 |     data=None,
 31 |     headers={},
 32 |     method="GET",
 33 |     verify=True,
 34 |     redirect=True,
 35 |     cookiejar=None,
 36 |     basic_auth=None,
 37 |     timeout=None,
 38 | ):
 39 |     """
 40 |     Returns a (named)tuple with the following properties:
 41 |         - request
 42 |         - content
 43 |         - json (dict; or None)
 44 |         - headers (dict; all lowercase keys)
 45 |             - https://stackoverflow.com/questions/5258977/are-http-headers-case-sensitive
 46 |         - status
 47 |         - url (final url, after any redirects)
 48 |         - cookiejar
 49 |     """
 50 |     method = method.upper()
 51 |     headers = {k.lower(): v for k, v in headers.items()}  # lowecase headers
 52 | 
 53 |     if params:
 54 |         url += "?" + urlencode(params)  # build URL from params
 55 |     if json and data:
 56 |         raise Exception("Cannot provide both json and data parameters")
 57 |     if method not in ["POST", "PATCH", "PUT"] and (json or data):
 58 |         raise Exception("Request method must POST, PATCH or PUT if json or data is provided")
 59 |     if not timeout:
 60 |         timeout = 60
 61 | 
 62 |     if json:  # if we have json, stringify and put it in our data variable
 63 |         headers["content-type"] = "application/json"
 64 |         data = json_lib.dumps(json).encode("utf-8")
 65 |     elif data:
 66 |         data = urlencode(data).encode()
 67 | 
 68 |     if basic_auth and len(basic_auth) == 2 and "authorization" not in headers:
 69 |         username, password = basic_auth
 70 |         headers["authorization"] = f'Basic {b64encode(f"{username}:{password}".encode()).decode("ascii")}'
 71 | 
 72 |     if not cookiejar:
 73 |         cookiejar = CookieJar()
 74 | 
 75 |     ctx = ssl.create_default_context()
 76 |     if not verify:  # ignore ssl errors
 77 |         ctx.check_hostname = False
 78 |         ctx.verify_mode = ssl.CERT_NONE
 79 | 
 80 |     handlers = []
 81 |     handlers.append(HTTPSHandler(context=ctx))
 82 |     handlers.append(HTTPCookieProcessor(cookiejar=cookiejar))
 83 | 
 84 |     if not redirect:
 85 |         no_redirect = NoRedirect()
 86 |         handlers.append(no_redirect)
 87 | 
 88 |     opener = build_opener(*handlers)
 89 |     req = Request(url, data=data, headers=headers, method=method)
 90 | 
 91 |     try:
 92 |         with opener.open(req, timeout=timeout) as resp:
 93 |             status, content, resp_url = (resp.getcode(), resp.read(), resp.geturl())
 94 |             headers = {k.lower(): v for k, v in list(resp.info().items())}
 95 | 
 96 |             if "gzip" in headers.get("content-encoding", ""):
 97 |                 content = gzip.decompress(content)
 98 | 
 99 |             json = (
100 |                 json_lib.loads(content)
101 |                 if "application/json" in headers.get("content-type", "").lower() and content
102 |                 else None
103 |             )
104 |     except HTTPError as e:
105 |         status, content, resp_url = (e.code, e.read(), e.geturl())
106 |         headers = {k.lower(): v for k, v in list(e.headers.items())}
107 | 
108 |         if "gzip" in headers.get("content-encoding", ""):
109 |             content = gzip.decompress(content)
110 | 
111 |         json = (
112 |             json_lib.loads(content)
113 |             if "application/json" in headers.get("content-type", "").lower() and content
114 |             else None
115 |         )
116 | 
117 |     return Response(req, content, json, status, resp_url, headers, cookiejar)
118 | 
119 | 
120 | import unittest
121 | 
122 | 
123 | class RequestTestCase(unittest.TestCase):
124 |     def test_cannot_provide_json_and_data(self):
125 |         with self.assertRaises(Exception):
126 |             request(
127 |                 "https://httpbingo.org/post",
128 |                 json={"name": "Brenton"},
129 |                 data="This is some form data",
130 |             )
131 | 
132 |     def test_should_fail_if_json_or_data_and_not_p_method(self):
133 |         with self.assertRaises(Exception):
134 |             request("https://httpbingo.org/post", json={"name": "Brenton"})
135 | 
136 |         with self.assertRaises(Exception):
137 |             request("https://httpbingo.org/post", json={"name": "Brenton"}, method="HEAD")
138 | 
139 |     def test_should_set_content_type_for_json_request(self):
140 |         response = request("https://httpbingo.org/post", json={"name": "Brenton"}, method="POST")
141 |         self.assertEqual(response.request.headers["Content-type"], "application/json")
142 | 
143 |     def test_should_work(self):
144 |         response = request("https://httpbingo.org/get")
145 |         self.assertEqual(response.status, 200)
146 | 
147 |     def test_should_create_url_from_params(self):
148 |         response = request(
149 |             "https://httpbingo.org/get",
150 |             params={"name": "brenton", "library": "tiny-request"},
151 |         )
152 |         self.assertEqual(response.url, "https://httpbingo.org/get?name=brenton&library=tiny-request")
153 | 
154 |     def test_should_return_headers(self):
155 |         response = request("https://httpbingo.org/response-headers", params={"Test-Header": "value"})
156 |         self.assertEqual(response.headers["test-header"], "value")
157 | 
158 |     def test_should_populate_json(self):
159 |         response = request("https://httpbingo.org/json")
160 |         self.assertTrue("slideshow" in response.json)
161 | 
162 |     def test_should_return_response_for_404(self):
163 |         response = request("https://httpbingo.org/404")
164 |         self.assertEqual(response.status, 404)
165 |         self.assertTrue("text/plain" in response.headers["content-type"])
166 | 
167 |     def test_should_fail_with_bad_ssl(self):
168 |         with self.assertRaises(URLError):
169 |             response = request("https://expired.badssl.com/")
170 | 
171 |     def test_should_load_bad_ssl_with_verify_false(self):
172 |         response = request("https://expired.badssl.com/", verify=False)
173 |         self.assertEqual(response.status, 200)
174 | 
175 |     def test_should_form_encode_non_json_post_requests(self):
176 |         response = request("https://httpbingo.org/post", data={"name": "test-user"}, method="POST")
177 |         self.assertEqual(response.json["form"]["name"], ["test-user"])
178 | 
179 |     def test_should_follow_redirect(self):
180 |         response = request(
181 |             "https://httpbingo.org/redirect-to",
182 |             params={"url": "https://duckduckgo.com/"},
183 |         )
184 |         self.assertEqual(response.url, "https://duckduckgo.com/")
185 |         self.assertEqual(response.status, 200)
186 | 
187 |     def test_should_not_follow_redirect_if_redirect_false(self):
188 |         response = request(
189 |             "https://httpbingo.org/redirect-to",
190 |             params={"url": "https://duckduckgo.com/"},
191 |             redirect=False,
192 |         )
193 |         self.assertEqual(response.status, 302)
194 | 
195 |     def test_cookies(self):
196 |         response = request(
197 |             "https://httpbingo.org/cookies/set",
198 |             params={"cookie": "test"},
199 |             redirect=False,
200 |         )
201 |         response = request("https://httpbingo.org/cookies", cookiejar=response.cookiejar)
202 |         self.assertEqual(response.json["cookie"], "test")
203 | 
204 |     def test_basic_auth(self):
205 |         response = request("http://httpbingo.org/basic-auth/user/passwd", basic_auth=("user", "passwd"))
206 |         self.assertEqual(response.json["authorized"], True)
207 | 
208 |     def test_should_handle_gzip(self):
209 |         response = request("http://httpbingo.org/gzip", headers={"Accept-Encoding": "gzip"})
210 |         self.assertEqual(response.json["gzipped"], True)
211 | 
212 |     def test_should_handle_gzip_error(self):
213 |         response = request("http://httpbingo.org/status/418", headers={"Accept-Encoding": "gzip"})
214 |         self.assertEqual(response.content, b"I'm a teapot!")
215 | 
216 |     def test_should_timeout(self):
217 |         import socket
218 | 
219 |         with self.assertRaises((TimeoutError, socket.timeout)):
220 |             response = request("http://httpbingo.org/delay/3", timeout=1)
221 | 
222 |     def test_should_handle_head_requests(self):
223 |         response = request("http://httpbingo.org/head", method="HEAD")
224 |         self.assertTrue(response.content == b"")
225 | 


--------------------------------------------------------------------------------
/djbs.py:
--------------------------------------------------------------------------------
  1 | import random
  2 | import secrets
  3 | import sys
  4 | from io import BytesIO
  5 | from pathlib import Path
  6 | from subprocess import run
  7 | from zipfile import ZipFile
  8 | 
  9 | from args import parse_args
 10 | from thttp import request
 11 | 
 12 | from textwrap import dedent
 13 | 
 14 | 
 15 | EXAMPLE_MANAGEMENT_COMMAND = """# Example management command
 16 | # https://docs.djangoproject.com/en/4.0/howto/custom-management-commands/
 17 | 
 18 | from django.core.management.base import BaseCommand, CommandError
 19 | 
 20 | 
 21 | class Command(BaseCommand):
 22 |     help = "An example management command created by djbs"
 23 | 
 24 |     def handle(self, *args, **options):
 25 |         self.stdout.write("Configure your management commands here...")
 26 |         raise CommandError("Management command not implemented")"""
 27 | 
 28 | 
 29 | def create_project_directory(dir):
 30 |     dir.mkdir()
 31 |     return dir
 32 | 
 33 | 
 34 | def django_install(dir):
 35 |     run(["pipenv install django"], shell=True, check=True, cwd=dir)
 36 | 
 37 | 
 38 | def django_startproject(dir, project_name):
 39 |     run(
 40 |         [f"pipenv run django-admin startproject {project_name} ."],
 41 |         shell=True,
 42 |         check=True,
 43 |         cwd=dir,
 44 |     )
 45 | 
 46 | 
 47 | def django_secret_key_in_env(dir, project_name):
 48 |     settings = open(dir / project_name / "settings.py", "r").read().splitlines()
 49 | 
 50 |     for i, l in enumerate(settings):
 51 |         if l.startswith("from pathlib import Path"):
 52 |             settings[i] = "import os\nfrom pathlib import Path"
 53 | 
 54 |         if l.startswith("SECRET_KEY ="):
 55 |             settings[i] = f'SECRET_KEY = os.environ.get("DJANGO_SECRET_KEY", "totally-insecure")'
 56 | 
 57 |         if l.startswith("DEBUG ="):
 58 |             settings[i] = (
 59 |                 l
 60 |                 + "\n"
 61 |                 + """if not DEBUG and SECRET_KEY == "totally-insecure":
 62 |     raise Exception("Do not run with the default secret key in production")"""
 63 |             )
 64 | 
 65 |     with open(dir / project_name / "settings.py", "w") as f:
 66 |         f.write("\n".join(settings))
 67 | 
 68 |     with open(dir / ".env", "w") as f:
 69 |         f.write(f"DJANGO_SECRET_KEY={secrets.token_urlsafe(40)}")
 70 | 
 71 | 
 72 | def django_set_allowed_hosts(dir, project_name, domain):
 73 |     settings = open(dir / project_name / "settings.py", "r").read()
 74 |     settings = settings.replace("ALLOWED_HOSTS = []", f'ALLOWED_HOSTS = ["{domain}", "localhost"]')
 75 | 
 76 |     with open(dir / project_name / "settings.py", "w") as f:
 77 |         f.write(settings)
 78 | 
 79 | 
 80 | def django_startapp(dir, app_name):
 81 |     run(
 82 |         [f"pipenv run python manage.py startapp {app_name}"],
 83 |         shell=True,
 84 |         check=True,
 85 |         cwd=dir,
 86 |     )
 87 | 
 88 | 
 89 | def django_run_migrations(dir, app_name):
 90 |     run([f"pipenv run python manage.py migrate"], shell=True, check=True, cwd=dir)
 91 | 
 92 | 
 93 | def django_add_app_to_installed_apps(dir, project_name, app):
 94 |     settings = open(dir / project_name / "settings.py", "r").read()
 95 |     settings = settings.replace('"django.contrib.staticfiles",', f'"django.contrib.staticfiles",\n    "{app}",')
 96 | 
 97 |     with open(dir / project_name / "settings.py", "w") as f:
 98 |         f.write(settings)
 99 | 
100 | 
101 | def django_add_base_template(dir, project_name, app):
102 |     p = dir / app / "templates"
103 |     p.mkdir()
104 | 
105 |     basehtml = request("https://basehtml.xyz").content.decode()
106 |     basehtml = basehtml.split("<!--")[0] + "{% block content %}{% endblock %}\n\n</body>\n</html>"
107 | 
108 |     with open(p / "base.html", "w") as f:
109 |         f.write(basehtml)
110 | 
111 | 
112 | def django_add_management_command(dir, project_name, app):
113 |     management_command_dir = dir / app / "management" / "commands"
114 |     management_command_dir.mkdir(parents=True)
115 | 
116 |     with open(management_command_dir / "example_command.py", "w") as f:
117 |         f.write(EXAMPLE_MANAGEMENT_COMMAND)
118 | 
119 |     with open(dir / app / "management" / "__init__.py", "w") as f:
120 |         f.write("")
121 | 
122 |     with open(management_command_dir / "__init__.py", "w") as f:
123 |         f.write("")
124 | 
125 | 
126 | def django_add_style_css(dir, project_name, app):
127 |     p = dir / app / "static" / "css"
128 |     p.mkdir(parents=True)
129 | 
130 |     with open(p / "style.css", "w") as f:
131 |         f.write("")
132 | 
133 | 
134 | def django_add_favicon(dir, project_name, app):
135 |     favicon = request("https://raw.githubusercontent.com/sesh/favicons/main/ico/grape-circle.ico").content
136 | 
137 |     with open(dir / app / "static" / "favicon.ico", "wb") as f:
138 |         f.write(favicon)
139 | 
140 | 
141 | def django_add_up(dir, project_name):
142 |     django_up_zip = BytesIO(request("https://github.com/sesh/django-up/archive/refs/heads/main.zip").content)
143 | 
144 |     z = ZipFile(django_up_zip)
145 |     z.extractall(dir)
146 |     Path(dir / "django-up-main").replace(dir / "up")
147 | 
148 |     django_add_app_to_installed_apps(dir, project_name, "up")
149 | 
150 |     run("pipenv install pyyaml dj-database-url", shell=True, check=True, cwd=dir)
151 | 
152 |     settings = open(dir / project_name / "settings.py", "r").read()
153 |     settings_before, settings_after = (
154 |         settings.split("DATABASES =")[0][:-12],
155 |         settings.split("DATABASES =")[1].split("}", 2)[2],
156 |     )
157 | 
158 |     settings = (
159 |         settings_before
160 |         + """\n\nimport dj_database_url
161 | DATABASES = {
162 |     'default': dj_database_url.config(default=f'sqlite:///{BASE_DIR / "db.sqlite3"}')
163 | }"""
164 |         + settings_after
165 |     )
166 | 
167 |     settings += "\n\n"
168 |     settings += "# Django Up\n"
169 |     settings += "# https://github.com/sesh/django-up\n\n"
170 |     settings += f"UP_GUNICORN_PORT = {random.randint(11000, 20000)}\n"
171 |     settings += "SECURE_PROXY_SSL_HEADER = ('HTTP_X_SCHEME', 'https')\n"
172 | 
173 |     with open(dir / project_name / "settings.py", "w") as f:
174 |         f.write(settings)
175 | 
176 | 
177 | def django_add_authuser(dir, project_name):
178 |     django_authuser_zip = BytesIO(
179 |         request("https://github.com/sesh/django-authuser/archive/refs/heads/main.zip").content
180 |     )
181 | 
182 |     z = ZipFile(django_authuser_zip)
183 |     z.extractall(dir)
184 |     Path(dir / "django-authuser-main").replace(dir / "authuser")
185 | 
186 |     django_add_app_to_installed_apps(dir, project_name, "authuser")
187 | 
188 |     settings = open(dir / project_name / "settings.py", "r").read()
189 |     settings += '\n\n# Custom user model\n\nAUTH_USER_MODEL = "authuser.User"\nAUTH_USER_ALLOW_SIGNUP = True\n'
190 | 
191 |     with open(dir / project_name / "settings.py", "w") as f:
192 |         f.write(settings)
193 | 
194 |     urls = open(dir / project_name / "urls.py", "r").read()
195 |     urls = urls.replace("]", "    path('accounts/', include('authuser.urls')),\n]")
196 |     urls = urls.replace("from django.urls import path", "from django.urls import include, path")
197 | 
198 |     with open(dir / project_name / "urls.py", "w") as f:
199 |         f.write(urls)
200 | 
201 | 
202 | def django_add_default_logging(dir, project_name):
203 |     settings = open(dir / project_name / "settings.py", "r").read()
204 | 
205 |     settings += "\n\n"
206 |     settings += "# Logging Configuration\n"
207 |     settings += "if DEBUG == False:\n"
208 |     settings += "    LOGGING = {\n"
209 |     settings += '        "version": 1,\n'
210 |     settings += '        "disable_existing_loggers": False,\n'
211 |     settings += '        "handlers": {\n'
212 |     settings += '            "file": {\n'
213 |     settings += '                "level": "DEBUG",\n'
214 |     settings += '                "class": "logging.FileHandler",\n'
215 |     settings += f'                "filename": "/srv/www/{project_name}/logs/debug.log",\n'
216 |     settings += "            },\n"
217 |     settings += "        },\n"
218 |     settings += '        "loggers": {\n'
219 |     settings += '            "django": {\n'
220 |     settings += '                "handlers": ["file"],\n'
221 |     settings += '                "level": "DEBUG",\n'
222 |     settings += '                "propagate": True,\n'
223 |     settings += "            },\n"
224 |     settings += "        },\n"
225 |     settings += "    }\n"
226 | 
227 |     with open(dir / project_name / "settings.py", "w") as f:
228 |         f.write(settings)
229 | 
230 | 
231 | def django_add_wellknown_urls(dir, project_name):
232 |     urls = open(dir / project_name / "urls.py", "r").read()
233 |     urlpatterns = """from django.http import HttpResponse
234 | 
235 | def robots(request):
236 |     return HttpResponse(
237 |         "User-Agent: *", headers={"Content-Type": "text/plain; charset=UTF-8"}
238 |     )
239 | 
240 | 
241 | def security(request):
242 |     return HttpResponse(
243 |         "Contact: <your-email>\\nExpires: 2025-01-01T00:00:00.000Z",
244 |         headers={"Content-Type": "text/plain; charset=UTF-8"},
245 |     )
246 | 
247 | 
248 | def trigger_error(request):
249 |     division_by_zero = 1 / 0
250 | 
251 | 
252 | urlpatterns = [
253 |     # .well-known
254 |     path("robots.txt", robots),
255 |     path(".well-known/security.txt", security),
256 |     path(".well-known/500", trigger_error),
257 | """
258 | 
259 |     urls = urls.replace("urlpatterns = [", urlpatterns)
260 |     with open(dir / project_name / "urls.py", "w") as f:
261 |         f.write(urls)
262 | 
263 | 
264 | def django_set_staticfiles_storage(dir, project_name):
265 |     settings = open(dir / project_name / "settings.py", "r").read().splitlines()
266 | 
267 |     for i, l in enumerate(settings):
268 |         if l.startswith("STATIC_URL ="):
269 |             l += '\nif not DEBUG:\n    STATICFILES_STORAGE = "django.contrib.staticfiles.storage.ManifestStaticFilesStorage"'
270 |             settings[i] = l
271 | 
272 |     with open(dir / project_name / "settings.py", "w") as f:
273 |         f.write("\n".join(settings))
274 | 
275 | 
276 | def django_add_middleware(dir, project_name):
277 |     middleware = request("https://raw.githubusercontent.com/sesh/django-middleware/main/middleware.py").content.decode()
278 |     with open(dir / project_name / "middleware.py", "w") as f:
279 |         f.write(middleware)
280 | 
281 |     settings = open(dir / project_name / "settings.py", "r").read()
282 |     settings = settings.replace(
283 |         '"django.middleware.clickjacking.XFrameOptionsMiddleware",',
284 |         f"""'django.middleware.clickjacking.XFrameOptionsMiddleware',
285 |     '{project_name}.middleware.set_remote_addr',
286 |     '{project_name}.middleware.csp',
287 |     '{project_name}.middleware.permissions_policy',
288 |     '{project_name}.middleware.xss_protect',
289 |     '{project_name}.middleware.expect_ct',
290 |     '{project_name}.middleware.cache',
291 |     '{project_name}.middleware.corp_coop_coep',
292 |     '{project_name}.middleware.dns_prefetch',""",
293 |     )
294 | 
295 |     with open(dir / project_name / "settings.py", "w") as f:
296 |         f.write(settings)
297 | 
298 | 
299 | def django_add_sentry(dir, project_name):
300 |     settings = open(dir / project_name / "settings.py", "r").read()
301 |     settings += "\n\n"
302 |     settings += "# Sentry\n"
303 |     settings += "# https://sentry.io\n"
304 |     settings += "# Enabled by setting SENTRY_DSN, install sentry_sdk if you plan on using Sentry\n\n"
305 |     settings += 'SENTRY_DSN = os.environ.get("SENTRY_DSN", "")\n\n'
306 |     settings += "if SENTRY_DSN and not DEBUG:\n"
307 |     settings += "    import sentry_sdk\n"
308 |     settings += "    from sentry_sdk.integrations.django import DjangoIntegration\n"
309 |     settings += "    sentry_sdk.init(\n"
310 |     settings += "        dsn=SENTRY_DSN,\n"
311 |     settings += "        integrations=[\n"
312 |     settings += "            DjangoIntegration(),\n"
313 |     settings += "        ],\n"
314 |     settings += "        # Set traces_sample_rate to 1.0 to capture 100%\n"
315 |     settings += "        # of transactions for performance monitoring.\n"
316 |     settings += "        # We recommend adjusting this value in production.\n"
317 |     settings += "        traces_sample_rate=0.05,\n"
318 |     settings += "        # If you wish to associate users to errors (assuming you are using\n"
319 |     settings += "        # django.contrib.auth) you may enable sending PII data.\n"
320 |     settings += "        send_default_pii=False\n"
321 |     settings += "    )\n"
322 | 
323 |     with open(dir / project_name / "settings.py", "w") as f:
324 |         f.write(settings)
325 | 
326 | 
327 | def install_and_run_black(dir):
328 |     run("pipenv install --dev black", shell=True, check=True, cwd=dir)
329 |     run("pipenv run black .", shell=True, check=True, cwd=dir)
330 | 
331 | 
332 | def install_and_run_isort(dir):
333 |     run("pipenv install --dev isort", shell=True, check=True, cwd=dir)
334 |     run("pipenv run isort .", shell=True, check=True, cwd=dir)
335 | 
336 | 
337 | def add_pyproject(dir):
338 |     with open(dir / "pyproject.toml", "w") as f:
339 |         f.write(
340 |             """[tool.ruff]
341 | line-length = 120
342 | 
343 | [tool.black]
344 | line-length = 120
345 | 
346 | [tool.isort]
347 | profile = "black"
348 | """
349 |         )
350 | 
351 | 
352 | def add_readme(dir, project_name, domain):
353 |     with open(dir / "README.md", "w") as f:
354 |         f.write(
355 |             f"""# {project_name}
356 | 
357 | ## Usage
358 | 
359 | ### Running the initial migrations
360 | 
361 | ```bash
362 | pipenv run python manage.py migrate
363 | ```
364 | 
365 | ### Running the development server
366 | 
367 | ```bash
368 | pipenv run python manage.py runserver
369 | ```
370 | 
371 | ### Running the tests
372 | 
373 | ```bash
374 | pipenv run python manage.py test
375 | ```
376 | 
377 | ### Deploying to a VPS
378 | 
379 | Notes:
380 | 
381 | - Ansible must be installed on your local machine
382 | - Target should be running Ubuntu 22.04
383 | 
384 | ```bash
385 | pipenv run python manage.py up {domain} --email=<your-email>
386 | ```
387 | 
388 | ---
389 | 
390 | Generated with [sesh/djbs](https://github.com/sesh/djbs).
391 | """
392 |         )
393 | 
394 | 
395 | def add_gitignore(dir):
396 |     gitignore = request("https://raw.githubusercontent.com/github/gitignore/main/Python.gitignore").content.decode()
397 |     with open(dir / ".gitignore", "w") as f:
398 |         f.write(gitignore)
399 | 
400 | 
401 | def main(project_name, app_name, domain, base_dir):
402 |     p = Path(base_dir + project_name)
403 |     p = create_project_directory(p)
404 | 
405 |     django_install(p)
406 |     django_startproject(p, project_name)
407 |     django_secret_key_in_env(p, project_name)
408 |     django_set_allowed_hosts(p, project_name, domain)
409 |     django_set_staticfiles_storage(p, project_name)
410 |     django_add_default_logging(p, project_name)
411 |     django_startapp(p, app_name)
412 |     django_add_app_to_installed_apps(p, project_name, app_name)
413 |     django_add_base_template(p, project_name, app_name)
414 |     django_add_style_css(p, project_name, app_name)
415 |     django_add_management_command(p, project_name, app_name)
416 |     django_add_favicon(p, project_name, app_name)
417 |     django_add_up(p, project_name)
418 |     django_add_authuser(p, project_name)
419 |     django_add_wellknown_urls(p, project_name)
420 |     django_add_sentry(p, project_name)
421 |     django_add_middleware(p, project_name)
422 |     django_run_migrations(p, project_name)
423 |     add_readme(p, project_name, domain)
424 |     add_pyproject(p)
425 |     add_gitignore(p)
426 | 
427 |     install_and_run_black(p)
428 |     install_and_run_isort(p)
429 | 
430 | 
431 | if __name__ == "__main__":
432 |     project_name = input("Project name: ")
433 |     domain_name = input("Domain name: ")
434 | 
435 |     app_name = input("App name [core]:")
436 |     if not app_name:
437 |         app_name = "core"
438 | 
439 |     base_dir = input("Base directory [../]: ")
440 |     if not base_dir:
441 |         base_dir = "../"
442 | 
443 |     if not base_dir.endswith("/"):
444 |         cont = input("Base directory does not end with '/', continue (yN)? ")
445 |         if cont != "y":
446 |             sys.exit("Exiting..")
447 | 
448 |     main(project_name, app_name, domain_name, base_dir)
449 | 


--------------------------------------------------------------------------------