cleanup wip

Author: dantownsend

dev-requirements.txt

@@ -1,4 +1,4 @@
 ipdb==0.11
 ipython==7.1.1
 twine==1.12.1
-mypy==0.710
+mypy==0.720

piccolo/columns/base.py

@@ -1,7 +1,7 @@
+from __future__ import annotations
 import typing as t
-import warnings
 
-from .operators import (
+from piccolo.columns.operators import (
     Equal,
     GreaterEqualThan,
     GreaterThan,
@@ -13,36 +13,39 @@
     NotEqual,
     NotIn,
     NotLike,
-    Operator
+    Operator,
 )
-from .combination import Where
-from ..custom_types import Iterable
-from ..querystring import QueryString
+from piccolo.columns.combination import Where
+from piccolo.custom_types import Iterable
+from piccolo.querystring import QueryString
+from piccolo.utils.warnings import colored_warning
 
 if t.TYPE_CHECKING:
-    from ..table import Table  # noqa
+    from piccolo.table import Table  # noqa
     from .column_types import ForeignKey  # noqa
 
 
-class Column():
+class Column:
 
     value_type: t.Type = int
 
+    # Set by Table metaclass:
+    _name: t.Optional[str] = None
+    _table: t.Optional[Table] = None
+
     def __init__(
         self,
         null: bool = True,
         primary: bool = False,
         key: bool = False,
-        unique: bool = False
+        unique: bool = False,
     ) -> None:
         self.null = null
         self.primary = primary
         self.key = key
         self.unique = unique
-        # Set by Table metaclass:
-        self._name: t.Optional[str] = None
         # Used by foreign keys:
-        self.call_chain: t.List['ForeignKey'] = []
+        self.call_chain: t.List["ForeignKey"] = []
         self.table_alias: t.Optional[str] = None
 
     def is_in(self, values: Iterable) -> Where:
@@ -52,25 +55,25 @@ def not_in(self, values: Iterable) -> Where:
         return Where(column=self, values=values, operator=NotIn)
 
     def like(self, value: str) -> Where:
-        if '%' not in value:
-            raise ValueError('% is required for like operators')
+        if "%" not in value:
+            raise ValueError("% is required for like operators")
         return Where(column=self, value=value, operator=Like)
 
     def ilike(self, value: str) -> Where:
-        if '%' not in value:
-            raise ValueError('% is required for ilike operators')
-        if self._table.Meta.db.engine_type == 'postgres':
+        if "%" not in value:
+            raise ValueError("% is required for ilike operators")
+        if self.engine_type == "postgres":
             operator: t.Type[Operator] = ILike
         else:
-            warnings.warn(
+            colored_warning(
                 "SQLite doesn't support ILIKE currently, falling back to LIKE."
             )
             operator = Like
         return Where(column=self, value=value, operator=operator)
 
     def not_like(self, value: str) -> Where:
-        if '%' not in value:
-            raise ValueError('% is required for like operators')
+        if "%" not in value:
+            raise ValueError("% is required for like operators")
         return Where(column=self, value=value, operator=NotLike)
 
     def __lt__(self, value) -> Where:
@@ -92,22 +95,49 @@ def __ne__(self, value) -> Where:  # type: ignore
         return Where(column=self, value=value, operator=NotEqual)
 
     def __hash__(self):
-        return hash(self._name)
+        return hash(self.name)
+
+    @property
+    def name(self) -> str:
+        if not self._name:
+            raise ValueError(
+                "`_name` isn't defined - the Table Metaclass should set it."
+            )
+        return self._name
+
+    @name.setter
+    def name(self, value: str):
+        self._name = value
+
+    @property
+    def table(self) -> Table:
+        if not self._table:
+            raise ValueError(
+                "`_table` isn't defined - the Table Metaclass should set it."
+            )
+        return self._table
+
+    @property
+    def engine_type(self) -> str:
+        engine = self.table.Meta.db
+        if engine:
+            return engine.engine_type
+        else:
+            raise ValueError("The table has no engine defined.")
 
-    def get_full_name(self, just_alias=False) -> str:
+    def _get_full_name(self, just_alias=False) -> str:
         """
         Returns the full column name, taking into account joins.
         """
-        column_name = self._name
+        column_name = self.name
 
         if not self.call_chain:
-            return f"{self._table.Meta.tablename}.{column_name}"
+            return f"{self.table.Meta.tablename}.{column_name}"
 
         column_name = (
-            "$".join([i._name for i in self.call_chain])
-            + f"${column_name}"
+            "$".join([i.name for i in self.call_chain]) + f"${column_name}"
         )
-        alias = f"{self.call_chain[-1].table_alias}.{self._name}"
+        alias = f"{self.call_chain[-1].table_alias}.{self.name}"
         if just_alias:
             return alias
         else:
@@ -118,23 +148,21 @@ def querystring(self) -> QueryString:
         """
         Used when creating tables.
         """
-        name = getattr(self, '_name', '')
+        name = getattr(self, "_name", "")
         column_type = getattr(
-            self,
-            'column_type',
-            self.__class__.__name__.upper()
+            self, "column_type", self.__class__.__name__.upper()
         )
-        query = f'{name} {column_type}'
+        query = f"{name} {column_type}"
         if self.primary:
-            query += ' PRIMARY'
+            query += " PRIMARY"
         if self.key:
-            query += ' KEY'
+            query += " KEY"
         if self.unique:
-            query += ' UNIQUE'
+            query += " UNIQUE"
 
-        references = getattr(self, 'references', None)
+        references = getattr(self, "references", None)
         if references:
-            query += f' REFERENCES {references.Meta.tablename}'
+            query += f" REFERENCES {references.Meta.tablename}"
 
         return QueryString(query)
 

piccolo/columns/column_types.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import copy
 from datetime import datetime
 import typing as t
@@ -6,70 +7,65 @@
 from piccolo.querystring import Unquoted
 
 if t.TYPE_CHECKING:
-    import table  # noqa
+    from piccolo.table import Table  # noqa
     from piccolo.custom_types import Datetime  # noqa
 
 
 class Varchar(Column):
 
     value_type = str
 
-    def __init__(self, length: int = 255, default: str = None,
-                 **kwargs) -> None:
+    def __init__(
+        self, length: int = 255, default: str = None, **kwargs
+    ) -> None:
         self.length = length
         self.default = default
         super().__init__(**kwargs)
 
 
 class Integer(Column):
-
     def __init__(self, default: int = None, **kwargs) -> None:
         self.default = default
         super().__init__(**kwargs)
 
 
 class Serial(Column):
-
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
 
 
-DEFAULT = Unquoted('DEFAULT')
-NULL = Unquoted('null')
+DEFAULT = Unquoted("DEFAULT")
+NULL = Unquoted("null")
 
 
 class PrimaryKey(Column):
-
     @property
     def column_type(self):
         engine_type = self._table.Meta.db.engine_type
-        if engine_type == 'postgres':
-            return 'SERIAL'
-        elif engine_type == 'sqlite':
-            return 'INTEGER'
-        raise Exception('Unrecognized engine type')
+        if engine_type == "postgres":
+            return "SERIAL"
+        elif engine_type == "sqlite":
+            return "INTEGER"
+        raise Exception("Unrecognized engine type")
 
     def default(self):
         engine_type = self._table.Meta.db.engine_type
-        if engine_type == 'postgres':
+        if engine_type == "postgres":
             return DEFAULT
-        elif engine_type == 'sqlite':
+        elif engine_type == "sqlite":
             return NULL
-        raise Exception('Unrecognized engine type')
+        raise Exception("Unrecognized engine type")
 
     def __init__(self, **kwargs) -> None:
-        kwargs.update({
-            'primary': True,
-            'key': True
-        })
+        kwargs.update({"primary": True, "key": True})
         super().__init__(**kwargs)
 
 
 class Timestamp(Column):
 
     value_type = datetime
 
-    def __init__(self, default: 'Datetime' = None, **kwargs) -> None:
+    def __init__(self, default: "Datetime" = None, **kwargs) -> None:
         self.default = default
         super().__init__(**kwargs)
 
@@ -112,9 +108,9 @@ class ForeignKey(Integer):
 
     """
 
-    column_type = 'INTEGER'
+    column_type = "INTEGER"
 
-    def __getattribute__(self, name):
+    def __getattribute__(self, name: str):
         """
         Returns attributes unmodified unless they're Column instances, in which
         case a copy is returned with an updated call_chain (which records the
@@ -128,7 +124,7 @@ def __getattribute__(self, name):
         except AttributeError:
             raise AttributeError
 
-        foreignkey_class = object.__getattribute__(self, '__class__')
+        foreignkey_class = object.__getattribute__(self, "__class__")
 
         if type(value) == foreignkey_class:  # i.e. a ForeignKey
             new_column = copy.deepcopy(value)
@@ -142,21 +138,21 @@ def __getattribute__(self, name):
             # will be raised. Often there are more effective ways of
             # structuring a query than joining so many tables anyway.
             if len(new_column.call_chain) > 10:
-                raise Exception('Call chain too long!')
+                raise Exception("Call chain too long!")
 
             for proxy_column in self.proxy_columns:
                 try:
-                    delattr(new_column, proxy_column._name)
+                    delattr(new_column, proxy_column.name)
                 except Exception:
                     pass
 
             for column in value.references.Meta.columns:
                 _column = copy.deepcopy(column)
                 _column.call_chain = copy.copy(new_column.call_chain)
                 _column.call_chain.append(new_column)
-                if _column._name == 'id':
+                if _column._name == "id":
                     continue
-                setattr(new_column, _column._name, _column)
+                setattr(new_column, _column.name, _column)
                 self.proxy_columns.append(_column)
 
             return new_column
@@ -168,7 +164,7 @@ def __getattribute__(self, name):
         else:
             return value
 
-    def __init__(self, references: t.Type['table.Table'], **kwargs) -> None:
+    def __init__(self, references: t.Type[Table], **kwargs) -> None:
         super().__init__(**kwargs)
         self.references = references
         self.proxy_columns: t.List[Column] = []
@@ -177,5 +173,5 @@ def __init__(self, references: t.Type['table.Table'], **kwargs) -> None:
         # completion.
         for column in references.Meta.columns:
             _column = copy.deepcopy(column)
-            setattr(self, column._name, _column)
+            setattr(self, _column.name, _column)
             self.proxy_columns.append(_column)