Refactored into a 'core' directory

Author: erezsh

preql/__init__.py

@@ -1,7 +1,7 @@
 from . import _base_imports
 
 from .api import Preql, T
-from .exceptions import Signal
+from .core.exceptions import Signal
 
 # import importlib.metadata as importlib_metadata
 # __version__ = importlib_metadata.version("prql")

preql/__main__.py

@@ -4,7 +4,7 @@
 import time
 
 from . import Preql, __version__, Signal
-from .display import display
+from .core.display import display
 
 parser = argparse.ArgumentParser(description='Preql command-line interface')
 parser.add_argument('-i', '--interactive', action='store_true', default=False,

preql/_base_imports.py

@@ -1 +1 @@
-from . import interp_common, pql_types, pql_objects, types_impl
+from .core import interp_common, pql_types, pql_objects, types_impl

preql/api.py

@@ -1,13 +1,13 @@
 from contextlib import contextmanager
 
 from . import settings
-from . import pql_ast as ast
-from . import pql_objects as objects
-from .interpreter import Interpreter
+from .core import pql_ast as ast
+from .core import pql_objects as objects
+from .core.interpreter import Interpreter
+from .core.pql_types import T
 from .sql_interface import create_engine
-from .pql_types import T
 
-from . import display
+from .core import display
 display.install_reprs()
 
 

preql/autocomplete.py preql/core/autocomplete.py

@@ -1,17 +1,17 @@
-from preql import settings
 from lark import Token, UnexpectedCharacters, UnexpectedToken, ParseError
 
+from preql.loggers import ac_log
+from preql.utils import bfs_all_unique, dy
+from preql.context import context
+
 from .exceptions import Signal, ReturnSignal, pql_SyntaxError
-from .loggers import ac_log
+from .compiler import AutocompleteSuggestions
+from .evaluate import evaluate, resolve
+from .interp_common import State
 from . import pql_ast as ast
 from . import pql_objects as objects
-from .utils import bfs_all_unique
-from .interp_common import State, dy
-from .evaluate import evaluate, resolve
-from .compiler import AutocompleteSuggestions
 from .pql_types import T
 from . import sql, parser
-from .context import context
 
 
 @dy

preql/base.py preql/core/base.py

@@ -1,10 +1,10 @@
 import operator
 
-from .utils import safezip, listgen, find_duplicate, SafeDict, re_split
-from .exceptions import Signal
-from . import exceptions as exc
 
-from . import settings
+from preql import settings
+from preql.utils import safezip, listgen, find_duplicate, SafeDict, re_split
+
+from .exceptions import Signal, InsufficientAccessLevel, ReturnSignal, pql_AttributeError
 from . import pql_objects as objects
 from . import pql_ast as ast
 from . import sql
@@ -27,11 +27,11 @@ def cast_to_instance(state, x):
         x = simplify(state, x)  # just compile Name?
         inst = compile_to_inst(state, x)
         # inst = evaluate(state, x)
-    except exc.ReturnSignal:
+    except ReturnSignal:
         raise Signal.make(T.CompileError, None, f"Bad compilation of {x}")
 
     if isinstance(inst, ast.ParameterizedSqlCode):
-        raise exc.InsufficientAccessLevel(inst)
+        raise InsufficientAccessLevel(inst)
 
     if not isinstance(inst, AbsInstance):
         # TODO compile error? cast error?
@@ -175,7 +175,7 @@ def compile_to_inst(state: State, proj: ast.Projection):
 
     for name, f in fields:
         if not f.type <= T.union[T.primitive, T.struct, T.json, T.nulltype, T.unknown]:
-            raise exc.Signal.make(T.TypeError, proj, f"Cannot project values of type: {f.type}")
+            raise Signal.make(T.TypeError, proj, f"Cannot project values of type: {f.type}")
 
     if isinstance(table, objects.StructInstance):
         d = {n[1]:c for n, c in fields}     # Remove used_defined bool
@@ -414,7 +414,7 @@ def _compare(state, op, a: T.type, b: T.type):
     if op == '<=':
         return call_builtin_func(state, "issubclass", [a, b])
     if op != '=':
-        raise exc.Signal.make(T.NotImplementedError, op, f"Cannot compare types using: {op}")
+        raise Signal.make(T.NotImplementedError, op, f"Cannot compare types using: {op}")
     return new_value_instance(a == b)
 
 @dp_inst
@@ -536,7 +536,7 @@ def _compile_arith(state, arith, a: T.string, b: T.string):
         return objects.Instance.make(code, T.bool, [a, b])
 
     if arith.op != '+':
-        raise exc.Signal.make(T.TypeError, arith.op, f"Operator '{arith.op}' not supported for strings.")
+        raise Signal.make(T.TypeError, arith.op, f"Operator '{arith.op}' not supported for strings.")
 
     if settings.optimize and isinstance(a, objects.ValueInstance) and isinstance(b, objects.ValueInstance):
         # Local folding for better performance (optional, for better performance)
@@ -691,7 +691,7 @@ def compile_to_inst(state: State, rps: ast.ParameterizedSqlCode):
             assert t[0] == '$'
             if t == '$self':
                 if self_table is None:
-                    raise exc.Signal.make(T.TypeError, rps, f"$self is only available for queries that return a table")
+                    raise Signal.make(T.TypeError, rps, f"$self is only available for queries that return a table")
                 inst = self_table
             else:
                 obj = state.get_var(t[1:])
@@ -783,7 +783,7 @@ def compile_to_inst(state: State, sel: ast.Selection):
     else:
         for i, c in enumerate(conds):
             if not c.type <= T.bool:
-                raise exc.Signal.make(T.TypeError, sel.conds[i], f"Selection expected boolean, got {c.type}")
+                raise Signal.make(T.TypeError, sel.conds[i], f"Selection expected boolean, got {c.type}")
 
         code = sql.table_selection(table, [c.code for c in conds])
 
@@ -794,7 +794,7 @@ def compile_to_inst(state: State, param: ast.Parameter):
     if state.access_level == state.AccessLevels.COMPILE:
         if param.type <= T.struct:
             # TODO why can't I just make an instance?
-            raise exc.InsufficientAccessLevel("Structs not supported yet")
+            raise InsufficientAccessLevel("Structs not supported yet")
         return make_instance(sql.Parameter(param.type, param.name), param.type, [])
 
     return state.get_var(param.name)
@@ -815,7 +815,7 @@ def compile_to_inst(state: State, attr: ast.Attr):
     inst = evaluate(state, attr.expr)
     try:
         return evaluate(state, inst.get_attr(attr.name))
-    except exc.pql_AttributeError as e:
+    except pql_AttributeError as e:
         raise Signal.make(T.AttributeError, attr, e.message)
 
 
@@ -828,7 +828,7 @@ def _apply_type_generics(state, gen_type, type_names):
         if not isinstance(o, Type):
             if isinstance(o.code, sql.Parameter):
                 # XXX hacky test, hacky solution
-                raise exc.InsufficientAccessLevel()
+                raise InsufficientAccessLevel()
             raise Signal.make(T.TypeError, None, f"Generics expression expected a type, got '{o}'.")
 
     if len(type_objs) > 1:

preql/casts.py preql/core/casts.py

@@ -4,14 +4,15 @@
 import rich.text
 import rich.console
 
+from preql.context import context
+
 from .exceptions import Signal
 from .pql_types import T, ITEM_NAME
 from . import pql_objects as objects
 from . import pql_ast as ast
 from .types_impl import dp_type, pql_repr
 from .interp_common import call_builtin_func, cast_to_python_int, cast_to_python
 
-from .context import context
 
 TABLE_PREVIEW_SIZE = 16
 LIST_PREVIEW_SIZE = 128

preql/compiler.py preql/core/compiler.py

@@ -2,22 +2,24 @@
 import logging
 from pathlib import Path
 
-from .utils import safezip, dataclass, SafeDict, listgen
+from preql.utils import safezip, dataclass, SafeDict, listgen
+from preql import settings
+
 from .interp_common import assert_type, exclude_fields, call_builtin_func, is_global_scope, cast_to_python_string, cast_to_python_int
 from .exceptions import InsufficientAccessLevel, ReturnSignal, Signal
 from . import exceptions as exc
 from . import pql_objects as objects
 from . import pql_ast as ast
 from . import sql
-from . import settings
 from .parser import Str
-
 from .interp_common import State, dy, new_value_instance, cast_to_python
 from .compiler import compile_to_inst, cast_to_instance
 from .pql_types import T, Type, Object, Id
 from .types_impl import table_params, table_flat_for_insert, flatten_type, pql_repr, kernel_type
 from .display import display
 
+MODULES_PATH = Path(__file__).parent.parent / 'modules' 
+
 
 @dy
 def resolve(state: State, struct_def: ast.StructDef):
@@ -302,8 +304,9 @@ def _execute(state: State, t: ast.Try):
         else:
             raise
 
+
 def import_module(state, r):
-    paths = [Path(__file__).parent / 'modules', Path.cwd()]
+    paths = [MODULES_PATH, Path.cwd()]
     for path in paths:
         module_path =  (path / r.module_path).with_suffix(".pql")
         if module_path.exists():
@@ -1016,7 +1019,7 @@ def function_localize_keys(self, state, struct):
 objects.Function._localize_keys = function_localize_keys
 
 
-from .context import context
+from preql.context import context
 def instance_repr(self):
     return pql_repr(self.type, localize(context.state, self))
 

preql/display.py preql/core/display.py

@@ -2,10 +2,11 @@
 
 from lark.exceptions import GrammarError
 
-from .utils import dataclass, TextReference
+from preql.utils import dataclass, TextReference
+from preql.context import context
+
 from .base import Object
 
-from .context import context
 
 @dataclass
 class Signal(Object, Exception):

preql/evaluate.py preql/core/evaluate.py

@@ -1,15 +1,15 @@
 from contextlib import contextmanager
 from copy import copy
 from logging import getLogger
-from datetime import datetime
+
+from preql.utils import dy
+from preql.sql_interface import ConnectError, create_engine
 
 from . import pql_ast as ast
 from . import pql_objects as objects
-from .utils import dy
 from .exceptions import Signal
 from .exceptions import InsufficientAccessLevel
 from .pql_types import Type, T
-from .sql_interface import ConnectError, create_engine
 
 logger = getLogger('interp')
 

preql/exceptions.py preql/core/exceptions.py

@@ -1,18 +1,18 @@
 from pathlib import Path
 from functools import wraps
 
-from .utils import classify
+from preql.utils import classify
+from preql.context import context
+
 from .exceptions import Signal, pql_SyntaxError, ReturnSignal
 from .evaluate import State, execute, eval_func_call, import_module, evaluate, localize, cast_to_python
 from .parser import parse_stmts
 from . import pql_ast as ast
 from . import pql_objects as objects
 from .interp_common import new_value_instance, call_builtin_func
-from .context import context
+from .pql_types import T, Object
 from .pql_functions import import_pandas
-
 from .pql_functions import internal_funcs, joins
-from .pql_types import T, Object
 
 
 def initial_namespace():

preql/interp_common.py preql/core/interp_common.py

@@ -3,7 +3,8 @@
 
 from lark import Lark, Transformer, v_args, UnexpectedInput, UnexpectedToken
 
-from .utils import TextPos, TextRange, TextReference
+from preql.utils import TextPos, TextRange, TextReference
+
 from .exceptions import pql_SyntaxError
 from . import pql_ast as ast
 from . import pql_objects as objects

preql/interpreter.py preql/core/interpreter.py

@@ -1,7 +1,8 @@
 from typing import List, Any, Optional, Dict, Union
 from dataclasses import field
 
-from .utils import dataclass, TextReference, field_list
+from preql.utils import dataclass, TextReference, field_list
+
 from . import pql_types as types
 from .pql_types import T, Object
 from .types_impl import pql_repr

preql/parser.py preql/core/parser.py

@@ -8,7 +8,9 @@
 import rich.progress
 import runtype
 
-from .utils import safezip, listgen, re_split
+from preql.utils import safezip, listgen, re_split
+from preql.docstring.autodoc import autodoc, AutoDocError
+
 from .exceptions import Signal, ExitInterp
 from . import pql_objects as objects
 from . import pql_ast as ast
@@ -18,7 +20,6 @@
 from .pql_types import T, Type, Id
 from .types_impl import join_names
 from .casts import cast
-from .docstring.autodoc import autodoc, AutoDocError
 from .compiler import cast_to_instance
 
 def new_str(x):

preql/pql_ast.py preql/core/pql_ast.py

@@ -4,9 +4,10 @@
 
 from typing import List, Optional, Callable, Any, Dict
 
-from .utils import dataclass, SafeDict, X, listgen
+from preql.utils import dataclass, SafeDict, X, listgen
+from preql import settings
+
 from .exceptions import pql_AttributeError, Signal
-from . import settings
 from . import pql_ast as ast
 from . import sql
 from . import pql_types

preql/pql_functions.py preql/core/pql_functions.py

@@ -8,8 +8,8 @@
 import runtype
 from runtype.typesystem import TypeSystem
 
+from preql.utils import dataclass
 from .base import Object
-from .utils import dataclass
 
 global_methods = {}
 

preql/pql_objects.py preql/core/pql_objects.py

@@ -3,12 +3,13 @@
 from datetime import datetime
 from typing import List, Optional, Dict
 
-from .utils import dataclass, X, listgen, field_list, safezip
+from preql.utils import dataclass, X, listgen, field_list, safezip
+from preql.context import context
+
 from . import pql_types
 from .pql_types import T, Type, dp_type, dp_inst, Id
 from .types_impl import join_names, flatten_type
 from .exceptions import Signal
-from .context import context
 
 duck = 'duck'
 sqlite = 'sqlite'

preql/pql_types.py preql/core/pql_types.py

@@ -1,7 +1,8 @@
 from .exceptions import Signal, pql_AttributeError
 
+from preql.utils import concat_for, classify_bool
+
 from .base import Object
-from .utils import concat_for, classify_bool
 from .pql_types import ITEM_NAME, T, Type, dp_type
 
 

preql/preql.lark preql/core/preql.lark

@@ -5,8 +5,9 @@
 from preql.utils import safezip, dy
 
 from preql.docstring.docstring import parse, Section, Defin, Text
-from preql.pql_objects import Module, Function, T
-from preql.pql_types import Type, subtypes
+
+from preql.core.pql_objects import Module, Function, T
+from preql.core.pql_types import Type, subtypes
 
 from . import type_docs
 

preql/sql.py preql/core/sql.py

@@ -1,4 +1,4 @@
-from preql.pql_types import T
+from preql.core.pql_types import T
 
 DOCS = {
 T.any: """A meta-type that can match any type.