Build an abstraction layer on top of Flask-Mail (or similar). Try to simplify the process of handling emails and make it fit in with other aspects and features of Ask. This abstraction layer should work in a similar way as e.g. random does.

Links:

• https://pythonbasics.org/flask-mail/#:~:text=Web%2Dbased%20applications%20typically%20require,interface%20with%20any%20email%20server.
• https://pythonhosted.org/Flask-Mail/
• https://pypi.org/project/Flask-Mail/

All string concatenations e.g. "hello " + my_var should be switched over to f-strings: f'hello {my_var}

The keyword else is not part of the transpiled code. Just the colon.

Build syntax highlighting and language support for Ask in Jetbrains IDE(s).

Run db.create_all() if any database models are added or updated. Not only if the database file doesn't exist.

Add a new module called _random. It should work like _hash and _env do (they get added in as boilerplate code on lines 514-662 in ask.py). Behind the scenes, this should use Pythons own built-in random library.

It should have the following functions:

# Single items
_random.int(0, 8) # Returns a random integer between 0 and 8.
_random.float(1.5, 3.8) # Returns a random float between 1.5 and 3.8.
_random.item(['a', 'b', 'c']) # Returns a random element from the passed in list.

# Multiple items
_random.ints(0, 8, 3) # Returns 3 random integers between 0 and 8 in a list.
_random.floats(1.5, 3.8, 8) # Returns 8 random floats between 1.5 and 3.8.
_random.items(['a', 'b', 'c'], 4) # Returns 4 random elements from the passed in list.

# You can add more functions if you want but at least these ones as a start...

Helpful links

• https://docs.python.org/3/library/random.html
• https://www.w3schools.com/python/module_random.asp

Currently all origins are allowed by default. The user should be able to define what origins are allowed. This is built into Flask Cors. Ask uses Flask Cors behind the scenes, so this should be fairly straightforward.

Docs for Flask Cors: https://flask-cors.readthedocs.io/en/latest/

The configuration options should be loaded from the Askfile.toml

Add support for the sqlalchemy data type: DateTime, this will be done in the same way as: db.String, db.Integer, and so on...

Add functions for working with regexes and also add support for abnex*.
The regex functions should use the same naming as the Abnex functions. So not the same as the re library.

* = https://github.com/Buscedv/abnormal-expressions

Add support for file uploads request type. From e.g. HTML forms.

Remove the need for if 'name' in _body and 'bithday' in _body and 'email' in _body and so on with a simple expression like this:

@post('/user'):
  required = ['name', 'birthday', 'email']

  if require_keys(required, _body):
    print(...)
    ...

This can be built in a similar way as deep() and quick_set() are built.

Decorators

The ability to "insert" both built-in (part of Ask) and user-made code/functionality into functions.

Usage

Decorating a function and/or route

&[decorator goes here]
def [function]([params]): # OR: @[method]([route]): 

Creating a decorator

decorator [decorator name goes here]:
  # Code goes here...
  ...

Simple Example

decorator my_first_decorator:
  print('Before')
  _inner()
  print('After')

&my_first_decorator
def my_function(message):
  print(message)

my_function('Hello')

Transpiled result

...

def my_first_decorator(func):
  def wrapper(*args, *kwargs):
    print('Before')
    func(*args, *kwargs)
  return wrapper

@my_first_decorator
def my_function(message):
  print(message)

my_function('Hello')

...

Output

Before
Hello
After

Ideas

• Built-in decorator names should start with: _, e.g. _a_built_in_decorator.
• See issue #35 & #25 for more examples.

Add a $_hash built-in variable.

You should be able to use Ask without running $ python3 ask.py [myfile].ask, you should be able to run: $ ask [myfile].ask. This could be done with e.g. PyInstaller or something similar.

Related to #66

I believe this should be possible because Ask is written in flask. If we manage to pull this off, I would start using Ask in all of my web app projects.

Make it easier to create basic login & signup routes. This could be solved with templating (a new concept that doesn't exist yet)

With a decorator:

&_login
@post('/login'):

With templating

&protected
@post('/login'):
  %_login%

A few new features are missing in the documentation.

• Decorators.
• the &basic decorator.
• Relationships (not ready yet see: #51).
• The custom db property in the Askfile.
• Sending request with an API token.
• HTTP status codes.
• the require_keys() function.
• DateTime db datatype.
• Random.
• Auto docs.

Variables can not contain words like: not, in, and, ...

All places where the \033[Xm syntax is used, a method should be called instead.

Build support for an "Askfile" that gives configuration options to the transpiler. Ex. support for naming the database file something else.

There should be a way to split your Ask apps into multiple files and still manage them as a whole in some way. This could be done e.g. with clever imports and flask blueprint (or similar).

Right now errors are shown like "normal" python errors, and the traceback comes from the app.py file, this is a problem since the function names, line numbers, etc. doesn't match the source .ask file. The line numbers are incorrect due to the boilerplate code that gets inserted into app.py but also other stuff like routes (they are defined on one line in Ask but two in Flask/Python).

TODO

• Correct line numbers.
• "Clean up" the traceback, make it easier to read.
• Add a flag (e.g. -e) that allows the user to see the full error messages if they please.
• Catch all errors and show Ask customized/cleaned up messages in their place.
• Log files, activate by either a flag (-l) or a config in the Askfile (or both).

First steps

• Figure out a way to calculate which line number in app.py corresponds to which line in the source .ask file.
• Capture the error messages.
• Parse the error messages.

Helpful links:

https://flask.palletsprojects.com/en/master/errorhandling/#generic-exception-handlers

Ideas and thoughts are welcome. This might be a bit hard for new contributors but feel free to comment and help out if you want.

We need unit tests!

Specs

• Preferably use Pythons built-in unittest framework.
• The tests should be in a script called: test_ask.py
• The most important methods to test are (in no particular order):
  • get_root_from_file_path()
  • route_path_to_func_name()
  • maybe_place_space_before()
  • route_params()
  • get_current_tab_level()
  • parser() ❗️
  • lex_var_keyword()
  • add_part()
  • fix_up_code_line()
  • lexer() ❗️

(❗️= complicated tests required)

Indentation often breaks when you add in comments.

It would be really nice to have automatic api documentation generated with every Ask app. This could be done with ex. Flask-selfdoc.

Functions like index(), int(), ect.. Gets transpiled to in dex(), and i nt(). Becouse the lexer thinks that the in part is the keyword in.

Ask should start a development server (flask run) if the transpiler is running in dev mode or if production configurations aren't present in the Askfile. The production server should then start automatically with a NO SETUP REQUIRED approach (but it should be customizable if the user wants to). The production server could e.g. be Gunicorn.

The transpiler enters DEV mode when the user runs ask with the -d flag:

$ python3 ask.py main.ask -d

Production "mode" could be activated in the Askfile like this:

{
  "run": {
    "production": true,
    ...
  },
  ...
}

Automatically generate _init() and s() methods for all database classes/models. This could be done with templating, see #46 for more info,

%_db_init%

Make it easy to send emails via e.g. gmail from Ask apps. This integration of Flask-Mail should at least support the features used in this tutorial: https://pythonprogramming.net/flask-email-tutorial/

Remove the need for .first() at the end. Or maybe create a new function ex. _db.get_one_by().

Add in tools and functions for adding login and web token authentication systems.

Add support for the foreign key data type and other relationship related sqlalchemy features & keywords.

Helpful links:

• https://docs.sqlalchemy.org/en/14/orm/basic_relationships.html

Right now by default the automatically started server (flask run) has flask's debug mode off. It should be turned on when Ask is run with the DEV flag -d. This can be achieved with environment variables. More specifically the FLASK_ENV variable. Read more: https://flask.palletsprojects.com/en/1.1.x/cli/#environments

Convert rule.keys() to list first

Make a built-in solution for storing lists in the database.

Do this with tables. Here is a working example but this needs to get implemented into Ask as a built-in behind the scenes feature.

db_class GenericList:
	id = _db.col(_db.int, _db.pk)

	def set_list(self, entry):
		if entry:
			for item in entry:
				self.push(item)

	def s(self):
		return {
			id: self.id,
			list: self.list()
		}

	def list(self):
		return [self.get(item.index) for item in GenericListItem._db.get_by(parent_id=self.id)]

	def push(self, item):
		new_item = GenericListItem(item, self.id)
		_db.add(new_item)

		return self.s()

	def get(self, index):
		item = GenericListItem._db.get_by(parent_id=self.id, index=index).first()

		return item.in_type()

	def remove(self, index):
		item = GenericListItem._db.get_by(parent_id=self.id, index=index).first()

		_db.delete(item)

db_class GenericListItem:
	id = _db.col(_db.int, _db.pk)
	index = _db.col(_db.int)
	item = _db.col(_db.bytes)
	parent_id = _db.col(_db.int)

	def _init(self, item, parent_id):
		self.item = pickle.dumps(item)
		self.parent_id = parent_id
		self.index = self.get_last_index() + 1

	def s(self):
		return {
			id: self.id,
			index: self.index,
			item: self.in_type(),
			parent_id: self.parent_id
		}

	def get_last_index(self):
		last_item = GenericListItem._db.get_by(parent_id=self.parent_id).order_by(_db.desc(GenericListItem.id)).first()

		if _db.exists(last_item):
			return last_item.index

		return -1

	def in_type(self):
		return pickle.loads(self.item)


def generic_list_factory(entry):
	generic_list = GenericList()
	_db.add(generic_list)
	generic_list.set_list(entry)

	return generic_list

Usage

my_list = generic_list_factory([1, 2, 3, 4])
print(my_list).list() # [1, 2, 3, 4]

my_list.push(5)
print(my_list).list() # [1, 2, 3, 4, 5]

my_list.remove(4)
print(my_list).list() # [1, 2, 3, 4]

print(my_list.get(0)) # 1

How it should work when it's built-in to Ask

my_list = _db.list([1, 2, 3, 4]) # or a single function e.g. my_list = make_list([1, 2, 3, 4])
my_list.push(5)
my_list.remove(4)
my_list.get(0)
my_list.list()

Another thought is that maybe we should add an alias for the _db.int type e.g. _db.list_id just for readabilities sake.