updating all references to relation to either table or query

Author: sculley

CHANGELOG.md

@@ -273,7 +273,7 @@ Documentation and tutorials available at https://docs.datajoint.io and https://t
 
 ### 0.3.4
 * Added method the `ERD.add_parts` method, which adds the part tables of all tables currently in the ERD.
-* `ERD() + arg` and `ERD() - arg` can now accept relation classes as arg.
+* `ERD() + arg` and `ERD() - arg` can now accept table classes as arg.
 
 ### 0.3.3
 * Suppressed warnings (redirected them to logging).  Previoiusly, scipy would throw warnings in ERD, for example.
@@ -283,5 +283,5 @@ Documentation and tutorials available at https://docs.datajoint.io and https://t
 
 ### 0.3.2.
 * Fixed issue #223:  `insert` can insert relations without fetching.
-* ERD() now takes the `context` argument, which specifies in which context to look for classes. The default is taken from the argument (schema or relation).
+* ERD() now takes the `context` argument, which specifies in which context to look for classes. The default is taken from the argument (schema or table).
 * ERD.draw() no longer has the `prefix` argument: class names are shown as found in the context.

datajoint/autopopulate.py

@@ -43,8 +43,8 @@ def _call_populate1(key):
 
 class AutoPopulate:
     """
-    AutoPopulate is a mixin class that adds the method populate() to a Relation class.
-    Auto-populated relations must inherit from both Relation and AutoPopulate,
+    AutoPopulate is a mixin class that adds the method populate() to a Table class.
+    Auto-populated tables must inherit from both Table and AutoPopulate,
     must define the property `key_source`, and must define the callback method `make`.
     """
 
@@ -117,7 +117,7 @@ def _job_key(self, key):
 
     def _jobs_to_do(self, restrictions):
         """
-        :return: the relation containing the keys to be computed (derived from self.key_source)
+        :return: the query yeilding the keys to be computed (derived from self.key_source)
         """
         if self.restriction:
             raise DataJointError(

datajoint/diagram.py

@@ -78,7 +78,7 @@ class Diagram(nx.DiGraph):
 
         >>>  diag = Diagram(source)
 
-        source can be a base relation object, a base relation class, a schema, or a module that has a schema.
+        source can be a base table object, a base table class, a schema, or a module that has a schema.
 
         >>> diag.draw()
 

datajoint/fetch.py

@@ -158,7 +158,7 @@ def __call__(
         unpacks blob attributes.
 
         :param attrs: zero or more attributes to fetch. If not provided, the call will return all attributes of this
-                        relation. If provided, returns tuples with an entry for each attribute.
+                        table. If provided, returns tuples with an entry for each attribute.
         :param offset: the number of tuples to skip in the returned result
         :param limit: the maximum number of tuples to return
         :param order_by: a single attribute or the list of attributes to order the results. No ordering should be assumed
@@ -170,7 +170,7 @@ def __call__(
                         True for .fetch('KEY')
         :param squeeze:  if True, remove extra dimensions from arrays
         :param download_path: for fetches that download data, e.g. attachments
-        :return: the contents of the relation in the form of a structured numpy.array or a dict list
+        :return: the contents of the table in the form of a structured numpy.array or a dict list
         """
         if order_by is not None:
             # if 'order_by' passed in a string, make into list
@@ -317,7 +317,7 @@ def __call__(self, *attrs, squeeze=False, download_path="."):
                  If attrs is empty, the return result is a dict
         :param squeeze:  When true, remove extra dimensions from arrays in attributes
         :param download_path: for fetches that download data, e.g. attachments
-        :return: the one tuple in the relation in the form of a dict
+        :return: the one tuple in the table in the form of a dict
         """
         heading = self._expression.heading
 

datajoint/heading.py

@@ -84,7 +84,7 @@ def original_name(self):
 
 class Heading:
     """
-    Local class for relations' headings.
+    Local class for table headings.
     Heading contains the property attributes, which is an dict in which the keys are
     the attribute names and the values are Attributes.
     """

datajoint/jobs.py

@@ -12,7 +12,7 @@
 
 class JobTable(Table):
     """
-    A base relation with no definition. Allows reserving jobs
+    A base table with no definition. Allows reserving jobs
     """
 
     def __init__(self, conn, database):

datajoint/preview.py

@@ -56,20 +56,20 @@ def repr_html(query_expression):
 
     css = """
     <style type="text/css">
-        .Relation{
+        .Table{
             border-collapse:collapse;
         }
-        .Relation th{
+        .Table th{
             background: #A0A0A0; color: #ffffff; padding:4px; border:#f0e0e0 1px solid;
             font-weight: normal; font-family: monospace; font-size: 100%;
         }
-        .Relation td{
+        .Table td{
             padding:4px; border:#f0e0e0 1px solid; font-size:100%;
         }
-        .Relation tr:nth-child(odd){
+        .Table tr:nth-child(odd){
             background: #ffffff;
         }
-        .Relation tr:nth-child(even){
+        .Table tr:nth-child(even){
             background: #f3f1ff;
         }
         /* Tooltip container */
@@ -111,7 +111,7 @@ def repr_html(query_expression):
     {css}
     {title}
         <div style="max-height:1000px;max-width:1500px;overflow:auto;">
-        <table border="1" class="Relation">
+        <table border="1" class="Table">
             <thead> <tr style="text-align: right;"> <th> {head} </th> </tr> </thead>
             <tbody> <tr> {body} </tr> </tbody>
         </table>

datajoint/schemas.py

@@ -171,7 +171,7 @@ def __call__(self, cls, *, context=None):
         context = context or self.context or inspect.currentframe().f_back.f_locals
         if issubclass(cls, Part):
             raise DataJointError(
-                "The schema decorator should not be applied to Part relations"
+                "The schema decorator should not be applied to Part tables."
             )
         if self.is_activated():
             self._decorate_master(cls, context)
@@ -282,7 +282,7 @@ def size_on_disk(self):
 
     def spawn_missing_classes(self, context=None):
         """
-        Creates the appropriate python user relation classes from tables in the schema and places them
+        Creates the appropriate python user table classes from tables in the schema and places them
         in the context.
 
         :param context: alternative context to place the missing classes into, e.g. locals()
@@ -319,7 +319,7 @@ def spawn_missing_classes(self, context=None):
                     if re.fullmatch(Part.tier_regexp, table_name):
                         part_tables.append(table_name)
                 else:
-                    # declare and decorate master relation classes
+                    # declare and decorate master table classes
                     context[class_name] = self(
                         type(class_name, (cls,), dict()), context=context
                     )

datajoint/table.py

@@ -355,7 +355,7 @@ def insert(
 
         Example:
 
-            >>> relation.insert([
+            >>> Table.insert([
             >>>     dict(subject_id=7, species="mouse", date_of_birth="2014-09-01"),
             >>>     dict(subject_id=8, species="mouse", date_of_birth="2014-09-02")])
         """
@@ -613,8 +613,7 @@ def cascade(table):
 
     def drop_quick(self):
         """
-        Drops the table associated with this relation without cascading and without user prompt.
-        If the table has any dependent table(s), this call will fail with an error.
+        Drops the table without cascading to dependent tables and without user prompt.
         """
         if self.is_declared:
             query = "DROP TABLE %s" % self.full_table_name
@@ -682,7 +681,7 @@ def show_definition(self):
 
     def describe(self, context=None, printout=True):
         """
-        :return:  the definition string for the relation using DataJoint DDL.
+        :return:  the definition string for the query using DataJoint DDL.
         """
         if context is None:
             frame = inspect.currentframe().f_back
@@ -1005,7 +1004,7 @@ def lookup_class_name(name, context, depth=3):
 
 class FreeTable(Table):
     """
-    A base relation without a dedicated class. Each instance is associated with a table
+    A base table without a dedicated class. Each instance is associated with a table
     specified by full_table_name.
 
     :param conn:  a dj.Connection object

datajoint/user_tables.py

@@ -1,5 +1,5 @@
 """
-Hosts the table tiers, user relations should be derived from.
+Hosts the table tiers, user tables should be derived from.
 """
 
 from .table import Table
@@ -83,7 +83,7 @@ def __iter__(cls):
 
 class UserTable(Table, metaclass=TableMeta):
     """
-    A subclass of UserTable is a dedicated class interfacing a base relation.
+    A subclass of UserTable is a dedicated class interfacing a base table.
     UserTable is initialized by the decorator generated by schema().
     """
 
@@ -164,7 +164,7 @@ class Imported(UserTable, AutoPopulate):
 
 class Computed(UserTable, AutoPopulate):
     """
-    Inherit from this class if the table's values are computed from other relations in the schema.
+    Inherit from this class if the table's values are computed from other tables in the schema.
     The inherited class must at least provide the function `_make_tuples`.
     """
 
@@ -174,10 +174,10 @@ class Computed(UserTable, AutoPopulate):
 
 class Part(UserTable):
     """
-    Inherit from this class if the table's values are details of an entry in another relation
-    and if this table is populated by this relation. For example, the entries inheriting from
+    Inherit from this class if the table's values are details of an entry in another table
+    and if this table is populated by the other table. For example, the entries inheriting from
     dj.Part could be single entries of a matrix, while the parent table refers to the entire matrix.
-    Part relations are implemented as classes inside classes.
+    Part tables are implemented as classes inside classes.
     """
 
     _connection = None