Not using Pokemon examples anymore

Author: dantownsend

docs/src/piccolo/design-decisions.rst

@@ -24,7 +24,7 @@ At any time you can access the __str__ method of a query, to see the underlying
 
 .. code-block:: python
 
-    query = Pokemon.select('name').where(Pokemon.power >= 100)
+    query = Band.select('name').where(Band.power >= 100)
 
     print(query)
-    'SELECT name from pokemon where power > 100'
+    'SELECT name from band where power > 100'

docs/src/piccolo/transactions.rst

@@ -11,7 +11,7 @@ Usage
 
 .. code-block:: python
 
-    transaction = Pokemon.Meta.db.transaction()
+    transaction = Band.Meta.db.transaction()
     transaction.add(Trainer.create())
     transaction.add(Match.create())
     await transaction.run()

piccolo/columns/column_types.py

@@ -75,32 +75,32 @@ class ForeignKey(Integer):
 
     http://www.postgresqltutorial.com/postgresql-foreign-key/
 
-    some_pokemon.trainer
+    some_band.trainer
     >>> 1
-    Pokemon.select('name', 'trainer.name')
+    Band.select('name', 'trainer.name')
 
     I'm not sure  about explicit joins ... only useful if we want to specify
     inner and outer joins.
 
-    Join(Pokemon, User)
+    Join(Band, User)
 
     To get the actual User object.
 
-    User.object().where(User.id == some_pokemon.trainer)
+    User.object().where(User.id == some_band.trainer)
 
     OR
 
-    some_pokemon.related_object('trainer')
+    some_band.related_object('trainer')
     > is just a proxy to the above
 
-    class Pokemon(Table):
+    class Band(Table):
         trainer = ForeignKey(User)
 
     To change the trainer:
-    some_pokemon.trainer = some_trainer_id
-    some_pokemon.save()
+    some_band.trainer = some_trainer_id
+    some_band.save()
     Or:
-    some_pokemon.set_related_object('trainer', some_trainer)
+    some_band.set_related_object('trainer', some_trainer)
 
     """
 

piccolo/query/methods/alter.py

@@ -7,7 +7,7 @@
 @dataclasses.dataclass
 class Rename():
     """
-    Pokemon.alter().rename(Pokemon.power, ‘rating’)
+    Band.alter().rename(Band.power, ‘rating’)
     """
     column: Column
     new_name: str
@@ -19,7 +19,7 @@ def __str__(self):
 @dataclasses.dataclass
 class Drop():
     """
-    Pokemon.alter().drop('power')
+    Band.alter().drop('power')
     """
     column: Column
 
@@ -30,7 +30,7 @@ def __str__(self):
 @dataclasses.dataclass
 class Add():
     """
-    Pokemon.alter().add(‘color’, Varchar(length=20))
+    Band.alter().add(‘color’, Varchar(length=20))
     """
     name: str
     column: Column

piccolo/table.py

@@ -120,7 +120,7 @@ def remove(self):
 
     def get_related(self, column_name: str):
         """
-        some_pokemon.get_related('trainer')
+        some_band.get_related('trainer')
         """
         cls = self.__class__
 
@@ -204,8 +204,8 @@ def select(cls, *column_names: str) -> Select:
     @classmethod
     def insert(cls, *rows: 'Table') -> Insert:
         """
-        await Pokemon.insert(
-            Pokemon(name="jigglypuff", power=500, trainer="florence")
+        await Band.insert(
+            Band(name="jigglypuff", power=500, trainer="florence")
         ).run()
         """
         query = Insert(
@@ -218,8 +218,8 @@ def insert(cls, *rows: 'Table') -> Insert:
     @classmethod
     def update(cls, **columns) -> Update:
         """
-        await Pokemon.update(name='raichu').where(
-            Pokemon.name='pikachu'
+        await Band.update(name='raichu').where(
+            Band.name='pikachu'
         ).run()
         """
         columns_str = ', '.join([
@@ -235,7 +235,7 @@ def update(cls, **columns) -> Update:
     @classmethod
     def delete(cls) -> Delete:
         """
-        await Pokemon.delete().where(Pokemon.name == 'weedle').run()
+        await Band.delete().where(Band.name == 'weedle').run()
         """
         return Delete(
             table=cls
@@ -246,7 +246,7 @@ def create(cls) -> Create:
         """
         Create table, along with all columns.
 
-        await Pokemon.create().run()
+        await Band.create().run()
         """
         return Create(
             table=cls,
@@ -257,7 +257,7 @@ def create_without_columns(cls) -> Raw:
         """
         Create the table, but with no columns (useful for migrations).
 
-        await Pokemon.create().run()
+        await Band.create().run()
         """
         return Raw(
             table=cls,
@@ -269,7 +269,7 @@ def drop(cls) -> Drop:
         """
         Drops the table.
 
-        await Pokemon.drop().run()
+        await Band.drop().run()
         """
         return Drop(
             table=cls,
@@ -278,7 +278,7 @@ def drop(cls) -> Drop:
     @classmethod
     def raw(cls, sql: str) -> Raw:
         """
-        await Pokemon.raw('select * from foo')
+        await Band.raw('select * from foo')
         """
         return Raw(
             table=cls,
@@ -288,7 +288,7 @@ def raw(cls, sql: str) -> Raw:
     @classmethod
     def alter(cls) -> Alter:
         """
-        await Pokemon.alter().rename(Pokemon.power, 'rating')
+        await Band.alter().rename(Band.power, 'rating')
         """
         return Alter(
             table=cls,

tests/base.py

@@ -3,22 +3,22 @@
 
 import asyncpg
 
-from .example_project.tables import Pokemon
+from .example_project.tables import Band
 
 
 class DBTestCase(TestCase):
 
     def run_sync(self, query):
         async def _run():
-            connection = await asyncpg.connect(**Pokemon.Meta.db.config)
+            connection = await asyncpg.connect(**Band.Meta.db.config)
             await connection.execute(query)
             await connection.close()
 
         asyncio.run(_run())
 
     def create_table(self):
         self.run_sync('''
-            CREATE TABLE pokemon (
+            CREATE TABLE band (
                 id SERIAL PRIMARY KEY,
                 name VARCHAR(50),
                 trainer VARCHAR(20),
@@ -27,7 +27,7 @@ def create_table(self):
 
     def insert_row(self):
         self.run_sync('''
-            INSERT INTO pokemon (
+            INSERT INTO band (
                 name,
                 trainer,
                 power
@@ -39,7 +39,7 @@ def insert_row(self):
 
     def insert_rows(self):
         self.run_sync('''
-            INSERT INTO pokemon (
+            INSERT INTO band (
                 name,
                 trainer,
                 power
@@ -58,7 +58,7 @@ def insert_rows(self):
             );''')
 
     def drop_table(self):
-        self.run_sync('DROP TABLE pokemon;')
+        self.run_sync('DROP TABLE band;')
 
     def setUp(self):
         self.create_table()

tests/engine/test_transaction.py

@@ -1,6 +1,6 @@
 from unittest import TestCase
 
-from ..example_project.tables import Pokemon, Trainer
+from ..example_project.tables import Band, Trainer
 
 
 class TestTransaction(TestCase):
@@ -9,40 +9,40 @@ def test_error(self):
         """
         Make sure queries in a transaction aren't committed if a query fails.
         """
-        transaction = Pokemon.Meta.db.transaction()
+        transaction = Band.Meta.db.transaction()
         transaction.add(
-            Pokemon.create(),
+            Band.create(),
             Trainer.create(),
-            Pokemon.raw('MALFORMED QUERY ... SHOULD ERROR')
+            Band.raw('MALFORMED QUERY ... SHOULD ERROR')
         )
         try:
             transaction.run_sync()
         except Exception as error:
             pass
         self.assertTrue(
-            not Pokemon.table_exists().run_sync()
+            not Band.table_exists().run_sync()
         )
         self.assertTrue(
             not Trainer.table_exists().run_sync()
         )
 
     def test_succeeds(self):
-        transaction = Pokemon.Meta.db.transaction()
+        transaction = Band.Meta.db.transaction()
         transaction.add(
-            Pokemon.create(),
+            Band.create(),
             Trainer.create()
         )
         transaction.run_sync()
 
         self.assertTrue(
-            Pokemon.table_exists().run_sync()
+            Band.table_exists().run_sync()
         )
         self.assertTrue(
             Trainer.table_exists().run_sync()
         )
 
         transaction.add(
-            Pokemon.drop(),
+            Band.drop(),
             Trainer.drop()
         )
         transaction.run_sync()

tests/example_project/tables.py

@@ -14,7 +14,7 @@
 ###############################################################################
 # Simple example
 
-class Pokemon(table.Table):
+class Band(table.Table):
     name = columns.Varchar(length=50)
     trainer = columns.Varchar(length=20)
     power = columns.Integer()
@@ -42,8 +42,8 @@ class Meta():
 
 
 class Match(table.Table):
-    pokemon_1 = columns.ForeignKey(Pokemon)
-    pokemon_2 = columns.ForeignKey(Pokemon)
+    band_1 = columns.ForeignKey(Band)
+    band_2 = columns.ForeignKey(Band)
     stadium = columns.ForeignKey(Stadium)
 
     class Meta():

tests/table/instance/test_delete.py

@@ -1,18 +1,18 @@
-from tests.example_project.tables import Pokemon
+from tests.example_project.tables import Band
 from tests.base import DBTestCase
 
 
 class TestDelete(DBTestCase):
 
     def setUp(self):
-        Pokemon.create().run_sync()
+        Band.create().run_sync()
 
     def tearDown(self):
-        Pokemon.drop().run_sync()
+        Band.drop().run_sync()
 
     def test_delete(self):
 
-        squirtle = Pokemon(
+        squirtle = Band(
             name='squirtle',
             trainer='Misty',
             power=300
@@ -22,6 +22,6 @@ def test_delete(self):
         squirtle.remove().run_sync()
 
         # how can I implement 'flat=True'
-        # Pokemon.select('name').output(as_list=True).run_sync()
+        # Band.select('name').output(as_list=True).run_sync()
         #
-        Pokemon.select('name').run_sync()
+        Band.select('name').run_sync()

tests/table/instance/test_get_related.py

@@ -1,30 +1,30 @@
 from unittest import TestCase
 
-from tests.example_project.tables import Pokemon, Stadium, Match
+from tests.example_project.tables import Band, Stadium, Match
 
 
 class TestGetRelated(TestCase):
 
     def setUp(self):
-        Pokemon.create().run_sync()
+        Band.create().run_sync()
         Stadium.create().run_sync()
         Match.create().run_sync()
 
     def tearDown(self):
         Match.drop().run_sync()
-        Pokemon.drop().run_sync()
+        Band.drop().run_sync()
         Stadium.drop().run_sync()
 
     def test_get_related(self):
         """
         Make sure you can get a related object from another object instance.
         """
-        pikachu = Pokemon(
+        pikachu = Band(
             name='pikachu'
         )
         pikachu.save().run_sync()
 
-        squirtle = Pokemon(
+        squirtle = Band(
             name='squirtle'
         )
         squirtle.save().run_sync()
@@ -35,8 +35,8 @@ def test_get_related(self):
         stadium.save().run_sync()
 
         match = Match(
-            pokemon_1=pikachu.id,
-            pokemon_2=squirtle.id,
+            band_1=pikachu.id,
+            band_2=squirtle.id,
             stadium=stadium.id
         )
         match.save().run_sync()