gibson-cli 0.1.0__py3-none-any.whl

gibson_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,102 @@
+api/BaseApi.py,sha256=W5C_Rq-sf_MOwArozYG0ILFL8nyXhSwX84dpLT69o1M,1055
+api/Cli.py,sha256=CPl_VnNuPyXkQNIv-YNfKpQbAdJIP8i2DeHbsmodXlA,8380
+bin/gibson.py,sha256=Ip7qGG6yR_lCQYkBTgfpMXS-OT2meB6kYnK9gL53hvI,340
+command/Api.py,sha256=-dGNE5StHlmN97g59mFraUZcaBEk5sBBMLShJoG4Yb8,961
+command/Base.py,sha256=OqN_O8wAq_swESCBQ1bF5j4AT1K4PAjep68u-WxGT7U,785
+command/BaseCommand.py,sha256=y0qD75qQ7b_phn3z2JSsraDpKovF_CEqiSUld_0LwrY,763
+command/Build.py,sha256=8Gw1dSakBsgNiAw5rKLTuhf6qAXGONQ--_XCx5j2k9s,2551
+command/Code.py,sha256=ltmU5htLvFShh-jgf0hdfKaENvkIE2vl_IGuGU_Z6K8,6725
+command/Conf.py,sha256=afZMpJ-tS1wcY3s6cjNjmW6d8hihRw-mZvaS7hFV47w,2376
+command/Count.py,sha256=xsYPRXP8TrW0T8P6uhjuovc28oR2iQgukL81eLoMpOc,976
+command/Dev.py,sha256=gD_0AeQ0uPNCMsYAAIrCJBefKicMaLYHmFf2kog7H-Y,4218
+command/Forget.py,sha256=iM8SdUMMdiw8Vbn3bJ6dgdnNXg-MIt3VM4G1ix3Kei4,1058
+command/Import.py,sha256=4jNHpKSn_vjCUC1GUY1ZiLiMpSJuWyxLYJBi2W_jfeQ,3649
+command/List.py,sha256=L2eTIxivZqalXQ4TwdSukGXVJ60bnPN0DA0MKdBfC84,2154
+command/Merge.py,sha256=afiEZaY7BPwV91S0T0KbZJ7JHh-BhoAvmQhbzyGZZJo,1069
+command/Model.py,sha256=P6Eo61zOj--C565m7nYe6lUnJJWr0utw7Eavlpt35VA,1195
+command/Models.py,sha256=wzJqqdvPr-7vn4F_zqKPr7f70qHe1k7nGtteEjRPoz0,897
+command/Modify.py,sha256=gRqbBdrUeRt1xhdAPNyiqgStTC3zrsm0EWng4FbwWgM,1256
+command/Module.py,sha256=LKBCYagACPLqSC4emRXszX_f3lvhlmD9Kgh0kzCto8I,1260
+command/New.py,sha256=ojmlN1YEs71uwouLDuSO_Eox4PDcTAZ8Sw32xWlrjWA,1137
+command/OpenApi.py,sha256=G8R_Dc8hPLCgWZAMNHIgHN9JBfnfDrDdT2ie0a-Rrx4,4321
+command/Question.py,sha256=vH04VrSXak4rOnYvV2e1eTGScli-_vIPyA9NR8PlmIA,3728
+command/Remove.py,sha256=vkBeD641MvbR9YwwXpq2Cej36QWwt-VTzn8XBDpxmpE,2356
+command/Rename.py,sha256=XOYAHkckYw5m4Vr_XomjkyhZT2QGlmv7yZnFUW38-3w,2186
+command/Rewrite.py,sha256=yh7IPjtN7y0YzXs9K-I5E47SRVziI7bp0gis_8S_PGM,3111
+command/Schema.py,sha256=U6SH_fTfEprIvvX8eDmHoMC4B6AfaGMrR17co13JO2M,1199
+command/Schemas.py,sha256=d4zgLFrXaaBSuAX8ouy429DXiWnx6uwEeFUDWAr4NmA,900
+command/Show.py,sha256=oNGKeNfEo6Qz1n4rJIRjlLuHWHWs5lB0TWE8Vn3hE2U,1190
+command/Test.py,sha256=2zfxSTm-lwvzERTZNgD99z-AtOWb4RdAN1B93aa-UEk,1194
+command/Tests.py,sha256=1l8iJs2W6fJDKMPL9Qdx7Qzm2I3azg_esthrZihK-S4,897
+command/Tree.py,sha256=JWvUimeHWY5-6vEh6axTkhAdI-dVTxbKSjx_4isAAx8,3041
+command/WarGames.py,sha256=vgMXSddUEU_PwDKyI7K0j-FN7uPs5jznfRj-CWh78FI,1280
+command/auth/Auth.py,sha256=taUwmwAsJWN19oKmjgVGhPA_A8vj6vQLmNUVkuiqfjg,666
+command/auth/Login.py,sha256=C3ZzV-Pp1C4RtAhpJ3IkJIwfgRY8pcUQmZRyMLT5hpU,454
+command/auth/Logout.py,sha256=kxyHEGUXp4Ql6VS9R0eQfZqRDf8yhAslZNXExwh1gjY,199
+command/tests/test_command_BaseCommand.py,sha256=BCeceiGl6ljjxkPiHMKzzrzjK1BUPWTHu9fTwGIETJI,350
+command/tests/test_command_Conf.py,sha256=4tgWLoIYNuv-bmCAFFy2Kl9nau5KtCwKJMKwMCfL8ow,569
+conf/Api.py,sha256=GM9okYs1A8ujPjDwzziOoQpqRYFkr-dz5pgkfb6j4DI,59
+conf/Code.py,sha256=3Bd5kxCbgWaUOyYLRejOO_SqM9spGk1dYAf2hYzuDSw,199
+conf/Custom.py,sha256=7S5v3bQK3UKuGUMTrAJeubWqszDtMlJI19-yOXk1TFs,101
+conf/Datastore.py,sha256=PVAnysrk4wH1oCWxTUaakH2_x83Zpm4vzD1ELhfMDSw,90
+conf/Dependencies.py,sha256=DZxyFtDR_3QpmsZbHApJFSeA7uYrMX1Bdx4lZKJ49Uo,891
+conf/Dev.py,sha256=xWccZPN5lW2j9O5ZfBDS9gMmxf75AhjGaDUnw0abEyo,316
+conf/Frameworks.py,sha256=Dv5iqeVe0JmNCKX5a-6S_dCrx7WZyI3qkTAFX6JWfDU,173
+conf/Modeler.py,sha256=RayW3VFD_2nCFXZepfEcCXTUX2tWd7WtOjHULNVCai8,67
+conf/Paths.py,sha256=NHJ_YLzmTIUUVLvtZornRdl1xPSluSmpFlMNsnqonxA,192
+conf/Platform.py,sha256=ai7bLab2Ak_zWiANJH78Pj3YjTlTCQ1EEtkFaVDijOc,307
+conf/Project.py,sha256=2lc_rr7giu1aGA4Ue4sU3Ey8-_yB2orLM1cw8f9zcdo,440
+conf/Version.py,sha256=S_mJGw2v6jONwOHFgzEGwVDr-Ng4M4a3Z6CPrF38TzM,33
+conf/dev/Api.py,sha256=EKZwy-3h7NxLdP6AYtwyTpJhD1kdQN6gVLuWw4_2KC8,158
+conf/dev/Base.py,sha256=HisA87syPa5sJFjfjyxWRkLIKuVM5CtAkwW3f2zJx5Y,72
+conf/dev/Model.py,sha256=HbHRX3VDxR7hXlzuxkKw4Bf7FH6XMfQ96k9BeIUoBf4,73
+conf/dev/Schema.py,sha256=kOSlX1jEyVb82xd8TO8jEAimLcaefIFJr6d2JYvyTqg,74
+conf/tests/test_conf_Dependencies.py,sha256=zmUFIANwpmFSMeEV5CllJstaqSSOBh9-Vgk-nETdlx0,109
+conf/tests/test_conf_Platform.py,sha256=amq1YqxHOXimIP6eIoSg-hAKZ8S68cDAXRdNEaTkdfw,131
+core/CommandRouter.py,sha256=fIzXKcGciMDHuXLkb6tp_N6sKs5SoqduCt-F1FE2U_c,9169
+core/Configuration.py,sha256=Rw8g0W11BK1TW7WdWef6tIB4YVLuRGiUtn-VjL8OFu0,13881
+core/Conversation.py,sha256=l9-8laUpHMtg14o4hzEho_CAX4Ahh2niVKUF3-0milI,8106
+core/Env.py,sha256=ulL7y1xqlz6Mrg_hVUM3NzSumDCI2B1Zjfz9StT2Ju0,413
+core/Memory.py,sha256=A7YtZFZwHqYpTFODsms8r_RNFNj3l-HKmaD8DhKH6So,3910
+core/TimeKeeper.py,sha256=0mzs04wizjGEJbiQFWZyi4ja4XgeJaDqc0JzPCHp9po,250
+core/utils.py,sha256=KTnPvA3sUYnLFTZG7Tke5YEdls8Da0rNbeaOm8hapiU,408
+data/default-ref-table.tmpl,sha256=cVqjTsmHDjmTGrbDEpNHaDG-GX1iWMzsQDXk5TASEXg,123
+data/default-table.tmpl,sha256=4t7SmXBuZN4nV5SjuQp6PBdo0-c3hdRnl8TQ2wdaS3w,247
+db/TableExceptions.py,sha256=F1NGHDhusg9E_3tLez1_abrbANtWyR0UtC_wE9CwNFE,137
+db/tests/test_db_TableExceptions.py,sha256=siPrXUBenRHW5nOO-n1eExTwgaJgZASAYdhDJXeXTJg,215
+dev/Dev.py,sha256=QWdzf1mvi95WCEMHnlnk8Xj5k75mBQE3-hTH3yiFESE,2888
+display/Header.py,sha256=moTxePVMNhtpeFtcI9EhnnLSK1gHIQiwYiWQtBPq_bY,298
+display/WorkspaceFooter.py,sha256=1-PsPtLcC7xUZLwufSSaVo9caXuyZEwfR_iZatxwHF4,316
+display/WorkspaceHeader.py,sha256=1oyyhZJF6C0SUCY2Cs_VkXt5Plp8xLb51XWa278l9mo,217
+display/tests/test_display_Header.py,sha256=rQ7ip3ViJ62H9sFFWGjsLEn8c4C2s4KJpFhaeah4crY,317
+display/tests/test_display_WorkspaceFooter.py,sha256=fDxXdwDmQLIRWYIBHbh32gfy2eW6Nlc4uq3wCOtGLIM,352
+display/tests/test_display_WorkspaceHeader.py,sha256=Mhloli8KkyVFqv3-Ci4CDggXjrdJ5xebyZmw4foxsuE,309
+lang/Python.py,sha256=qplU7xoplAIwWTTUSP1RcG3eMhHNUcbyJxCh1yZsXP8,1672
+lang/tests/test_lang_Python.py,sha256=nulN-VSftAG2BM9HGFUP2RGUHebJAOCWIVPLbHY96Uk,1961
+services/auth/Server.py,sha256=s5qNHxhY-ySSGa2RaK4zZIS3K908ulihx35d2F2Xg2k,1973
+services/code/context/schema/DataDictionary.py,sha256=zWLzxOzW8iMHxfXPEwnnbruEAtFa8j1UpghNd4AHzfA,369
+services/code/context/schema/EntityKeys.py,sha256=c8psaGfKseGN9V84xTjotgoLNs41sshbgX9K6ToFXHI,1548
+services/code/context/schema/Manager.py,sha256=rzj4eTfLn2NDJVop4VWqedNZ6oN0ST1hXqK54UwHe5A,892
+services/code/context/schema/tests/test_code_context_schema_DataDictionary.py,sha256=ASqifx7re5BU2RDKV3S0T00jxQTEiGEXa7rRcOeqa8E,357
+services/code/context/schema/tests/test_code_context_schema_EntityKeys.py,sha256=vdynazkI_TMGo5TVvhDeAelU08FrXOKMHx-jF05jOs0,2086
+services/code/context/schema/tests/test_code_context_schema_Manager.py,sha256=xVGeYj838VwhLNVIWYBDijBO7ObIPfSfVrU0DUlLweo,1216
+services/code/customization/Authenticator.py,sha256=5qnBjO_U7GhuQkC0boGgjqo5YTe-axyBWkl2ggkLg2I,1565
+services/code/customization/BaseCustomization.py,sha256=YZT3yP6cObTTPWjIvOyt5Cf6sRNVHtEXDJEmtcRRrzc,286
+services/code/customization/CustomizationManager.py,sha256=U4TFhIGUyUtJfeP72Ke9fxVTR3sonRDU2lFFLprCq68,570
+services/code/customization/tests/test_code_customization_Authenticator.py,sha256=eKOZ1F6zpSQsLo8bpjvcYozlGGGv8Gll7MSMXBWyUTs,1935
+services/code/customization/tests/test_code_customization_BaseCustomization.py,sha256=RUTepr2upveeEZowszk8HEEVBQ7y2MQin_Sh5BhKEAI,398
+structure/Entity.py,sha256=iDEtPy0fEAniABxffLxiYF6wWHQdrIWgW4L_-gB4hOA,3518
+structure/testing.py,sha256=NAXg4JWb_ysS-OCWZyJ4413vv7FnnWCyjD9Tj4dK_VM,7545
+structure/constraints/ReferenceConstraint.py,sha256=5zzKk--A2Bu1ZsN8QqS4jNILwq_BhOrV-f26WHKz5I0,1145
+structure/keys/ForeignKey.py,sha256=1XN_XssLz6NcQp3vf91TrBZ7006xZKnPnTexu-nvpKQ,1230
+structure/keys/Index.py,sha256=k5QfUyQM6hRkCNq1NtWWuAGxElmG4bXSCSRivzjr9g4,1694
+structure/keys/IndexAttribute.py,sha256=GL-ma2v_GidZ6jjIlFc6IWKe4Gtg4UJUlqf1cYisqS0,298
+structure/keys/tests/test_ForeignKey.py,sha256=rcNEgHpYjg5fYsbSHa1zd_N09NFRRyimDhVSnd13RQs,2261
+structure/keys/tests/test_Index.py,sha256=0ZFHEnU5DJBtxG2TCavVD13Rq6aloUXPFM1bspWhbXg,2163
+structure/keys/tests/test_IndexAttribute.py,sha256=_v3aKmL06cgXuV3xLXJMdp-8oPxHStj7qymtF3HtGrQ,381
+structure/tests/test_Entity.py,sha256=MYog9b_IV3gbfYx9_hPmCgX3JNPz0t6cXQ-LU1WobjE,3117
+gibson_cli-0.1.0.dist-info/METADATA,sha256=OMPI6DftiUJ_LO30DLGRDp9-d9nwswwLVQb9Lr77x2I,10886
+gibson_cli-0.1.0.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+gibson_cli-0.1.0.dist-info/entry_points.txt,sha256=VAGCYo_zQgGI5bYR4Ql4rHhl5Zt7iA-Irt1v4iriLvQ,43
+gibson_cli-0.1.0.dist-info/top_level.txt,sha256=e26JAjLAeXm2tl9nuW9OxrRvzkIXNYlXnHo-Yf5ZtnE,70
+gibson_cli-0.1.0.dist-info/RECORD,,

gibson_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (71.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gibson_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gibson = bin.gibson:main

gibson_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,12 @@
+api
+bin
+command
+conf
+core
+data
+db
+dev
+display
+lang
+services
+structure

lang/Python.py

@@ -0,0 +1,57 @@
+import os
+
+
+class Python:
+    def define_python_path(self, paths: list):
+        additions = []
+        for entry in paths:
+            path = self.make_python_path(entry)
+            if path is not None:
+                add_path = True
+                for addition in additions:
+                    if addition in path:
+                        add_path = False
+                        break
+
+                if add_path:
+                    additions.append(path)
+
+        if additions == []:
+            return None
+
+        return ":".join(additions)
+
+    def make_import_path(self, os_path):
+        if os_path is None:
+            return None
+
+        os_path = os.path.expandvars(os_path)
+
+        pythonpath = os.environ["PYTHONPATH"].split(":")
+        for entry in pythonpath:
+            path = os_path.replace(entry, "")
+            if path != os_path:
+                path = path.replace("/", ".")
+                if path in [None, ""]:
+                    # There is no import path, the file is at the top level.  Note,
+                    # this is explicitly not None as that will cause the back end
+                    # to incorrectly exclude the import.
+                    return ""
+
+                if path[0] == ".":
+                    path = path[1:]
+
+                return path
+
+        raise RuntimeError(
+            "cannot make import path; please execute:\n\n"
+            + f"    export PYTHONPATH=$PYTHONPATH:{os_path}\n"
+        )
+
+    def make_python_path(self, path):
+        pythonpath = os.environ["PYTHONPATH"].split(":")
+        for entry in pythonpath:
+            if entry in path:
+                return None
+
+        return path

lang/tests/test_lang_Python.py

@@ -0,0 +1,70 @@
+import os
+
+import pytest
+
+from lang.Python import Python
+
+
+def test_make_python_path_no_match():
+    assert Python().make_python_path("/a/b/c") == "/a/b/c"
+
+
+def test_make_python_path_match():
+    last_pythonpath = os.environ["PYTHONPATH"]
+
+    try:
+        os.environ["PYTHONPATH"] = "/a/b/c:/d/e/f"
+        assert Python().make_python_path("/a/b/c/g") is None
+        assert Python().make_python_path("/d/e/f/h") is None
+    finally:
+        os.environ["PYTHONPATH"] = last_pythonpath
+
+
+def test_define_python_path():
+    last_pythonpath = os.environ["PYTHONPATH"]
+
+    try:
+        os.environ["PYTHONPATH"] = "/a/b/c:/d/e/f"
+        assert Python().define_python_path(["/a/b/c", "/d/e/f"]) is None
+        assert Python().define_python_path(["/g/h/i", "/j/k/l"]) == "/g/h/i:/j/k/l"
+    finally:
+        os.environ["PYTHONPATH"] = last_pythonpath
+
+
+def test_make_import_path_exceptions():
+    with pytest.raises(RuntimeError) as e:
+        Python().make_import_path("/a/b/c")
+
+    assert str(e.value) == (
+        """cannot make import path; please execute:
+
+    export PYTHONPATH=$PYTHONPATH:/a/b/c
+"""
+    )
+
+
+def test_make_import_path():
+    last_pythonpath = os.environ["PYTHONPATH"]
+
+    try:
+        os.environ["PYTHONPATH"] = "/a/b/c"
+        assert Python().make_import_path(None) is None
+        assert Python().make_import_path("/a/b/c/services/base") == "services.base"
+        assert Python().make_import_path("/a/b/c/services/base/model") == (
+            "services.base.model"
+        )
+        assert Python().make_import_path("/a/b/c/services/base/schema") == (
+            "services.base.schema"
+        )
+    finally:
+        os.environ["PYTHONPATH"] = last_pythonpath
+
+
+def test_make_import_path_match_on_top_level():
+    last_pythonpath = os.environ["PYTHONPATH"]
+
+    try:
+        os.environ["PYTHONPATH"] = "/a/b/c"
+        assert Python().make_import_path("/a/b/c") == ""
+    finally:
+        os.environ["PYTHONPATH"] = last_pythonpath

services/auth/Server.py

@@ -0,0 +1,75 @@
+import webbrowser
+
+import time
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from threading import Thread
+from socket import socket
+from urllib.parse import urlparse, parse_qs
+
+
+# HTTP handler for processing the token sent from the web browser
+class Handler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        url = urlparse(self.path)
+        params = parse_qs(url.query)
+        token = params.get("token", [""])[0]
+
+        if token:
+            self.respond(200, "OK")
+            self.server.token = token
+        else:
+            self.respond(400, "Bad Request")
+
+        self.server._stop()
+
+    # Suppress logging
+    def log_message(self, format, *args):
+        pass
+
+    # Format the response
+    def respond(self, code, message):
+        self.send_response(code)
+        self.send_header("Content-type", "text")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header(
+            "Access-Control-Allow-Headers",
+            "Origin, X-Requested-With, Content-Type, Accept",
+        )
+        self.end_headers()
+        self.wfile.write(message.encode("utf8"))
+
+
+# Temporary HTTP server to handle the login process
+class Server(HTTPServer):
+    port = None
+    token = None
+    thread = None
+
+    def __init__(self, app_domain: str):
+        sock = socket()
+        sock.bind(("", 0))
+        self.port = sock.getsockname()[1]
+        super().__init__(("localhost", self.port), Handler)
+
+        self.app_domain = app_domain
+
+    def get_token(self):
+        self._start()
+        self._open_browser()
+
+        while self.thread is not None:
+            time.sleep(1)
+
+        return self.token
+
+    def _open_browser(self):
+        webbrowser.open(f"{self.app_domain}/signup?cli={self.port}")
+
+    def _start(self):
+        thread = Thread(target=self.serve_forever)
+        thread.start()
+        self.thread = thread
+
+    def _stop(self):
+        Thread(target=self.shutdown).start()
+        self.thread = None

services/code/context/schema/DataDictionary.py

@@ -0,0 +1,12 @@
+class DataDictionary:
+    def __init__(self):
+        self.__attributes = {}
+
+    def from_code_writer_schema_context(self, data: dict):
+        for name, definition in data.items():
+            self.__attributes[name] = definition
+
+        return self
+
+    def get_attribute_definition(self, attribute_name):
+        return self.__attributes.get(attribute_name, None)

services/code/context/schema/EntityKeys.py

@@ -0,0 +1,49 @@
+from structure.constraints.ReferenceConstraint import ReferenceConstraint
+from structure.keys.ForeignKey import ForeignKey
+from structure.keys.Index import Index
+
+
+class EntityKeys:
+    def __init__(self):
+        self.__entity_name = None
+        self.__index = []
+        self.__primary = []
+        self.__unique = []
+
+    def best_sql_foreign_key(self):
+        elements = []
+        if self.__primary != []:
+            elements = self.__primary
+        elif self.__unique != []:
+            elements = self.__unique
+
+        if elements == []:
+            return None
+
+        reference_constraint = ReferenceConstraint()
+        reference_constraint.attributes = []
+        reference_constraint.references = self.__entity_name
+
+        foreign_key = ForeignKey()
+        foreign_key.attributes = []
+        foreign_key.reference = reference_constraint
+
+        index = Index()
+
+        data_types = []
+        for element in elements:
+            foreign_key.attributes.append(f"{self.__entity_name}_{element['name']}")
+            reference_constraint.attributes.append(element["name"])
+            index.add_attribute(f"{self.__entity_name}_{element['name']}")
+            data_types.append(element["data"]["type"])
+
+        return foreign_key, index, data_types
+
+    def from_code_writer_schema_context(
+        self, entity_name: str, index: list, primary: list, unique: list
+    ):
+        self.__entity_name = entity_name
+        self.__index = index
+        self.__primary = primary
+        self.__unique = unique
+        return self

services/code/context/schema/Manager.py

@@ -0,0 +1,28 @@
+from services.code.context.schema.DataDictionary import DataDictionary
+from services.code.context.schema.EntityKeys import EntityKeys
+
+
+class Manager:
+    def __init__(self):
+        self.__entity_keys_map = {}
+        self.data_dictionary = DataDictionary()
+        self.json = None
+
+    def from_code_writer_schema_context(self, context: dict):
+        self.data_dictionary.from_code_writer_schema_context(
+            context["data"]["dictionary"]
+        )
+
+        for entity_name, keys in context["keys"].items():
+            self.__entity_keys_map[
+                entity_name
+            ] = EntityKeys().from_code_writer_schema_context(
+                entity_name, keys["index"], keys["primary"], keys["unique"]
+            )
+
+        self.json = context
+
+        return self
+
+    def get_entity_keys(self, entity_name):
+        return self.__entity_keys_map.get(entity_name, None)

services/code/context/schema/tests/test_code_context_schema_DataDictionary.py

@@ -0,0 +1,8 @@
+from services.code.context.schema.DataDictionary import DataDictionary
+
+
+def test_configure():
+    data_dict = DataDictionary().from_code_writer_schema_context({"a": "b", "c": "d"})
+    assert data_dict.get_attribute_definition("z") is None
+    assert data_dict.get_attribute_definition("a") == "b"
+    assert data_dict.get_attribute_definition("c") == "d"

services/code/context/schema/tests/test_code_context_schema_EntityKeys.py

@@ -0,0 +1,52 @@
+from services.code.context.schema.EntityKeys import EntityKeys
+from structure.constraints.ReferenceConstraint import ReferenceConstraint
+from structure.keys.ForeignKey import ForeignKey
+from structure.keys.Index import Index
+
+
+def test_best_sql_foreign_key_no_match():
+    assert EntityKeys().best_sql_foreign_key() is None
+
+
+def test_best_sql_foreign_key_choose_primary():
+    ek = EntityKeys().from_code_writer_schema_context(
+        "abc",
+        [],
+        [
+            {"data": {"type": "pk_type_1"}, "name": "pk_name_1"},
+            {"data": {"type": "pk_type_2"}, "name": "pk_name_2"},
+        ],
+        [{"data": {"type": "uk_type_1"}, "name": "uk_name_1"}],
+    )
+
+    foreign_key, index, data_types = ek.best_sql_foreign_key()
+    assert isinstance(foreign_key, ForeignKey)
+    assert isinstance(foreign_key.reference, ReferenceConstraint)
+    assert isinstance(index, Index)
+    assert foreign_key.attributes == ["abc_pk_name_1", "abc_pk_name_2"]
+    assert foreign_key.reference.attributes == ["pk_name_1", "pk_name_2"]
+    assert foreign_key.reference.references == "abc"
+    assert len(index.attributes) == 2
+    assert index.attributes[0].name == "abc_pk_name_1"
+    assert index.attributes[1].name == "abc_pk_name_2"
+    assert len(data_types) == 2
+    assert data_types[0] == "pk_type_1"
+    assert data_types[1] == "pk_type_2"
+
+
+def test_best_sql_foreign_key_choose_unique():
+    ek = EntityKeys().from_code_writer_schema_context(
+        "abc", [], [], [{"data": {"type": "uk_type_1"}, "name": "uk_name_1"}]
+    )
+
+    foreign_key, index, data_types = ek.best_sql_foreign_key()
+    assert isinstance(foreign_key, ForeignKey)
+    assert isinstance(foreign_key.reference, ReferenceConstraint)
+    assert isinstance(index, Index)
+    assert foreign_key.attributes == ["abc_uk_name_1"]
+    assert foreign_key.reference.attributes == ["uk_name_1"]
+    assert foreign_key.reference.references == "abc"
+    assert len(index.attributes) == 1
+    assert index.attributes[0].name == "abc_uk_name_1"
+    assert len(data_types) == 1
+    assert data_types[0] == "uk_type_1"

services/code/context/schema/tests/test_code_context_schema_Manager.py

@@ -0,0 +1,34 @@
+from services.code.context.schema.EntityKeys import EntityKeys
+from services.code.context.schema.Manager import Manager
+
+
+def test_get_entity_keys_no_such_entity_name():
+    assert Manager().get_entity_keys("abc") is None
+
+
+def test_from_code_writer_schema_context_data_dictionary():
+    context = {"data": {"dictionary": {"abc": "def", "ghi": "jkl"}}, "keys": {}}
+
+    manager = Manager().from_code_writer_schema_context(context)
+    assert manager.data_dictionary.get_attribute_definition("abc") == "def"
+    assert manager.data_dictionary.get_attribute_definition("ghi") == "jkl"
+
+
+def test_from_code_writer_schema_context_get_entity_keys():
+    context = {
+        "data": {"dictionary": {}},
+        "keys": {
+            "abc_def": {
+                "index": [],
+                "primary": [
+                    {"data": {"type": "pk_type_1"}, "name": "pk_name_1"},
+                    {"data": {"type": "pk_type_2"}, "name": "pk_name_2"},
+                ],
+                "unique": [],
+            }
+        },
+    }
+
+    manager = Manager().from_code_writer_schema_context(context)
+    assert manager.get_entity_keys("def_ghi") is None
+    assert isinstance(manager.get_entity_keys("abc_def"), EntityKeys)

services/code/customization/Authenticator.py

@@ -0,0 +1,51 @@
+import os
+
+from core.Configuration import Configuration
+from services.code.customization.BaseCustomization import BaseCustomization
+
+
+class Authenticator(BaseCustomization):
+    def __init__(self, configuration: Configuration):
+        super().__init__(configuration)
+        self.__link_target = None
+        self.__file_contents = None
+
+    def __get_file_name(self):
+        return (
+            self.configuration.project.dev.api.path
+            + "/"
+            + self.configuration.project.dev.api.version
+            + "/Authenticator.py"
+        )
+
+    def preserve(self):
+        authenticator_file_name = self.__get_file_name()
+
+        if os.path.islink(authenticator_file_name):
+            self.__link_target = os.readlink(authenticator_file_name)
+        elif os.path.isfile(authenticator_file_name):
+            with open(authenticator_file_name, "r") as f:
+                self.__file_contents = f.read()
+
+        return self
+
+    def restore(self):
+        authenticator_file_name = self.__get_file_name()
+
+        if self.__link_target is not None:
+            try:
+                os.unlink(authenticator_file_name)
+            except FileNotFoundError:
+                pass
+
+            os.symlink(self.__link_target, authenticator_file_name)
+        elif self.__file_contents is not None:
+            try:
+                os.unlink(authenticator_file_name)
+            except FileNotFoundError:
+                pass
+
+            with open(authenticator_file_name, "w") as f:
+                f.write(self.__file_contents)
+
+        return self

services/code/customization/BaseCustomization.py

@@ -0,0 +1,12 @@
+from core.Configuration import Configuration
+
+
+class BaseCustomization:
+    def __init__(self, configuration: Configuration):
+        self.configuration = configuration
+
+    def preserve(self):
+        raise NotImplementedError
+
+    def restore(self):
+        raise NotImplementedError

services/code/customization/CustomizationManager.py

@@ -0,0 +1,20 @@
+from core.Configuration import Configuration
+from services.code.customization.Authenticator import Authenticator
+
+
+class CustomizationManager:
+    def __init__(self, configuration: Configuration):
+        self.configuration = configuration
+        self.customizations = [Authenticator(self.configuration)]
+
+    def preserve(self):
+        for customization in self.customizations:
+            customization.preserve()
+
+        return self
+
+    def restore(self):
+        for customization in self.customizations:
+            customization.restore()
+
+        return self

services/code/customization/tests/test_code_customization_Authenticator.py

@@ -0,0 +1,53 @@
+import os
+import shutil
+
+from core.Configuration import Configuration
+from services.code.customization.Authenticator import Authenticator
+
+
+def test_link_target():
+    configuration = Configuration()
+    configuration.project.dev.api.path = "/tmp/gibsonai-unit-test"
+    configuration.project.dev.api.version = "v1"
+
+    try:
+        os.makedirs("/tmp/gibsonai-unit-test/v1")
+
+        os.symlink("/etc/passwd", "/tmp/gibsonai-unit-test/v1/Authenticator.py")
+
+        authenticator = Authenticator(configuration).preserve()
+        os.unlink("/tmp/gibsonai-unit-test/v1/Authenticator.py")
+        authenticator.restore()
+
+        assert os.path.islink("/tmp/gibsonai-unit-test/v1/Authenticator.py") is True
+        assert os.readlink("/tmp/gibsonai-unit-test/v1/Authenticator.py") == (
+            "/etc/passwd"
+        )
+    finally:
+        shutil.rmtree("/tmp/gibsonai-unit-test")
+
+
+def test_file_contents():
+    configuration = Configuration()
+    configuration.project.dev.api.path = "/tmp/gibsonai-unit-test"
+    configuration.project.dev.api.version = "v1"
+
+    try:
+        os.makedirs("/tmp/gibsonai-unit-test/v1")
+
+        with open("/tmp/gibsonai-unit-test/v1/Authenticator.py", "w") as f:
+            f.write("abc def\nghi jkl")
+
+        authenticator = Authenticator(configuration).preserve()
+        os.unlink("/tmp/gibsonai-unit-test/v1/Authenticator.py")
+        assert os.path.islink("/tmp/gibsonai-unit-test/v1/Authenticator.py") is False
+        assert os.path.isfile("/tmp/gibsonai-unit-test/v1/Authenticator.py") is False
+        authenticator.restore()
+
+        assert os.path.islink("/tmp/gibsonai-unit-test/v1/Authenticator.py") is False
+        assert os.path.isfile("/tmp/gibsonai-unit-test/v1/Authenticator.py") is True
+
+        with open("/tmp/gibsonai-unit-test/v1/Authenticator.py", "r") as f:
+            assert f.read() == "abc def\nghi jkl"
+    finally:
+        shutil.rmtree("/tmp/gibsonai-unit-test")