Mapping the Cerebral Organoid Landscape: A Systematic Review of Preclinical 3D Models in Neuroscience.

1. # Import required packages
3. from flask import Flask, jsonify, render_template,request
4. from flask_sqlalchemy import SQLAlchemy
5. from init import db
6. import pandas as pd
8. # Define app framework
10. app = Flask(__name__)
11. app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite3'
12. app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
15. db.init_app(app)
17. # -- Navigation routes --
19. @app.route('/')
20. def index():
21. return render_template("index.html")
23. @app.route('/legal')
24. def legal():
25. return render_template("legal.html")
27. # -- Database routes to fetch data --
29. # .. Route to fetch large table from database ..
30. @app.route("/fetch_large_table")
31. def fetch_large_table():
32. try:
33. entries = LargeTable.query.all()
35. entries_dict = [row.to_dict() for row in entries]
37. if not entries:
38. return jsonify({"error": "No entries found"}), 404
39. return jsonify(entries_dict), 200
41. except Exception as e:
42. return jsonify({"error": str(e)}), 500
45. # .. Route that fetches list of unique values for a specific column string ..
46. @app.route("/fetch_unique_entries")
47. def fetch_unique_entries():
48. try:
49. col = request.args.get('col')
51. entries = [entry[0] for entry in LargeTable.query.with_entities(getattr(LargeTable, col)).distinct().all()]
53. if not entries:
54. return jsonify({"error": "No entries found"}), 404
55. return jsonify(entries), 200
57. except Exception as e:
58. return jsonify({"error": str(e)}), 500
60. # .. Route to fetch abbreviations from database ..
61. @app.route("/fetch_abbreviations")
62. def fetch_abbreviations():
63. try:
64. abbreviations = Abbreviations.query.order_by(Abbreviations.abbreviation).all()
66. grouped_abbr = {}
68. for abbreviation in abbreviations:
69. key = abbreviation.abbreviation[0].lower()
70. grouped_abbr.setdefault(key, []).append(abbreviation.to_dict())
72. if not grouped_abbr:
73. return jsonify({"error": "No entries found"}), 404
75. return jsonify(grouped_abbr), 200
77. except Exception as e:
78. return jsonify({"error": str(e)}), 500
80. # Define the LargeTable (main table) model class
82. class LargeTable(db.Model):
83. id = db.Column(db.Integer, primary_key=True)
84. group = db.Column(db.String, nullable=False)
85. subgroup = db.Column(db.String, nullable=False)
86. focus = db.Column(db.String)
87. title = db.Column(db.String)
88. journal = db.Column(db.String)
89. year = db.Column(db.Integer, nullable=False)
90. doi = db.Column(db.String)
91. model = db.Column(db.String, nullable=False)
92. cell_origin = db.Column(db.String, nullable=False)
93. application = db.Column(db.String)
94. advantages = db.Column(db.String)
95. limitations = db.Column(db.String)
97. # Initialization of a db entry
98. def __init__(self, group, subgroup, focus, title, journal, year, doi, model, cell_origin, application, advantages, limitations):
99. self.group = group
100. self.subgroup = subgroup
101. self.focus = focus
102. self.title = title
103. self.journal = journal
104. self.year = year
105. self.doi = doi
106. self.model = model
107. self.cell_origin = cell_origin
108. self.application = application
109. self.advantages = advantages
110. self.limitations = limitations
112. # Conversion to dictionary
113. def to_dict(self):
115. return {
116. 'id': self.id,
117. 'group': self.group,
118. 'subgroup': self.subgroup,
119. 'focus' : self.focus,
120. 'title': self.title,
121. 'journal' : self.journal,
122. 'year': self.year,
123. 'doi': self.doi,
124. 'model': self.model,
125. 'cell_origin': self.cell_origin,
126. 'application': self.application,
127. 'advantages': self.advantages,
128. 'limitations': self.limitations
129. }
131. # Define the Abbreviations model
132. class Abbreviations(db.Model):
133. id = db.Column(db.Integer, primary_key=True)
134. abbreviation = db.Column(db.String(100), nullable=False)
135. description = db.Column(db.String(100), nullable=False)
137. # Initialization of db entry
138. def __init__(self, abbreviation, description):
140. self.abbreviation = abbreviation
141. self.description = description
143. # Conversion to dictionary
144. def to_dict(self):
146. return {
147. 'id': self.id,
148. 'abbreviation': self.abbreviation,
149. 'description': self.description
150. }
152. # Create the database in app context
154. with app.app_context():
155. db.create_all()
157. # Function for converting the abbreviations table to a database
159. def addLargeTable(excel_path):
161. df = pd.read_excel(excel_path, sheet_name='Map')
163. for _, row in df.iterrows():
165. entry = LargeTable(group=row['Group'], subgroup=row['Subgroup'], focus=row['Focus'], title=row['Title'],
166. journal=row['Journal'], year=row['Year'], cell_origin=row['Cell origin'], doi=row['DOI'],
167. model=row['Model'], application=row['Application'], advantages=row['Advantages'],
168. limitations=row['Limitations'])
169. db.session.add(entry)
171. db.session.commit()
173. # Function for converting the abbreviations table to a database
175. def addAbbreviations(excel_path):
177. df = pd.read_excel(excel_path, sheet_name='Abbreviations')
179. for _, row in df.iterrows():
181. entry = Abbreviations(abbreviation=row['Abbreviation'], description=row['Description'])
182. db.session.add(entry)
184. db.session.commit()
187. if __name__ == "__main__":
188. app.run(debug=True)

app.py at commit 6f90302, no license · at the source