remove Entity subclasses

Designating an object to be a member of an Entity subclass such as Association, rather than just an Entity, seems to be equivalent to creating a Fact that "X was an association", except that I don't know how to reason about a subclass relationship in all the ways I can reason about a Fact object.
mscarey · Jun 9, 2019 · 8f86422 · 8f86422
1 parent 6873b7f
commit 8f86422
Show file tree

Hide file tree

Showing 14 changed files with 44 additions and 114 deletions.
diff --git a/authorityspoke/entities.py b/authorityspoke/entities.py
diff --git a/authorityspoke/factors.py b/authorityspoke/factors.py
@@ -11,7 +11,7 @@
 from typing import Any, Callable, ClassVar, Dict, Iterable, Iterator, List
 from typing import Optional, Sequence, Set, Tuple, Type, Union
 
-from dataclasses import dataclass
+from dataclasses import astuple, dataclass
 
 from authorityspoke.context import log_mentioned_context
 from authorityspoke.predicates import Predicate
@@ -1084,7 +1084,12 @@ def means(left: Factor, right: Factor) -> bool:
 @dataclass(frozen=True)
 class Entity(Factor):
     """
-    A person, place, thing, or event that needs to be mentioned in
+    Things that exist in the outside world, like people, places, or events.
+
+    Not concepts that derive their meaning from litigation,
+    such as a legal Fact, an Allegation, a Pleading, etc.
+
+    Best used to specify things to be mentioned in
     multiple :class:`.Factor`\s in a :class:`.Rule`, often in the
     :class:`.Predicate` of a :class:`.Fact` object.
 

diff --git a/example_data/holdings/holding_brad.json b/example_data/holdings/holding_brad.json
@@ -6,15 +6,15 @@
             "name": "Bradley's house"
         },
         {
-            "type": "human",
+            "type": "entity",
             "name": "Bradley"
         },
         {
             "type": "entity",
             "name": "Bradley's marijuana patch"
         },
         {
-            "type": "event",
+            "type": "entity",
             "name": "officers' search of the yard"
         },
         {

diff --git a/example_data/holdings/holding_cardenas.json b/example_data/holdings/holding_cardenas.json
@@ -1,10 +1,10 @@
 {
     "mentioned_factors": [{
-            "type": "Human",
+            "type": "entity",
             "name": "defendant"
         },
         {
-            "type": "Human",
+            "type": "entity",
             "name": "parole officer"
         },
         {

diff --git a/example_data/holdings/holding_lotus.json b/example_data/holdings/holding_lotus.json
@@ -2,11 +2,11 @@
     "mentioned_factors": [
 
         {
-            "type": "association",
+            "type": "entity",
             "name": "Lotus Development Corporation"
         },
         {
-            "type": "association",
+            "type": "entity",
             "name": "Borland International"
         },
         {

diff --git a/example_data/holdings/holding_oracle.json b/example_data/holdings/holding_oracle.json
@@ -2,15 +2,15 @@
     "mentioned_factors": [
 
         {
-            "type": "association",
+            "type": "entity",
             "name": "Oracle America"
         },
         {
-            "type": "association",
+            "type": "entity",
             "name": "Google"
         },
         {
-            "type": "association",
+            "type": "entity",
             "name": "Sun Microsystems"
         },
         {

diff --git a/example_data/holdings/holding_watt.json b/example_data/holdings/holding_watt.json
@@ -6,15 +6,15 @@
             "name": "Hideaway Lodge"
         },
         {
-            "type": "human",
+            "type": "entity",
             "name": "Wattenburg"
         },
         {
             "type": "entity",
             "name": "the stockpile of trees"
         },
         {
-            "type": "event",
+            "type": "entity",
             "name": "officers' search of the stockpile"
         },
         {

diff --git a/notebooks/introduction.ipynb b/notebooks/introduction.ipynb
@@ -252,18 +252,7 @@
    "cell_type": "code",
    "execution_count": 11,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Code(\"cfr37.xml\")"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from authorityspoke import Code, Regime\n",
     "\n",
@@ -312,23 +301,23 @@
    "source": [
     "Before we see what that did, let's look at the format of the holding JSON files we just loaded in.\n",
     "\n",
-    "The top level of each of these JSON files has two fields: `\"mentioned_factors\"` and `\"holdings\"`. `\"mentioned_factors\"` is where you list the people, places, and things that need to be mentioned more than once to explain a holding. The reason you're listing these entities is so AuthoritySpoke will recognize that the same entities have been mentioned more than once in different contexts. Each of these entities has a `\"type\"` attribute, which will be the Python class name for the object that's created. You can use the generic type \"Entity\", or the more specific subtypes \"Association\", \"Human\", or \"Event\".\n",
+    "The top level of each of these JSON files has two fields: `\"mentioned_factors\"` and `\"holdings\"`. `\"mentioned_factors\"` is where you list the people, places, and things that need to be mentioned more than once to explain a holding. The reason you're listing these entities is so AuthoritySpoke will recognize that the same entities have been mentioned more than once in different contexts. Each of these entities has a `\"type\"` attribute, which will be the Python class name for the object that's created. You can use the generic type \"Entity\".\n",
     "\n",
     "Here's the `\"mentioned_factors\"` field from holding_oracle.json.\n",
     "\n",
     "```\n",
     "\"mentioned_factors\": [\n",
     "\n",
     "        {\n",
-    "            \"type\": \"association\",\n",
+    "            \"type\": \"entity\",\n",
     "            \"name\": \"Oracle America\"\n",
     "        },\n",
     "        {\n",
-    "            \"type\": \"association\",\n",
+    "            \"type\": \"entity\",\n",
     "            \"name\": \"Google\"\n",
     "        },\n",
     "        {\n",
-    "            \"type\": \"association\",\n",
+    "            \"type\": \"entity\",\n",
     "            \"name\": \"Sun Microsystems\"\n",
     "        },\n",
     "        {\n",
@@ -589,7 +578,7 @@
     {
      "data": {
       "text/plain": [
-       "[Association(name='Borland International', generic=True, plural=False),\n",
+       "[Entity(name='Borland International', generic=True, plural=False),\n",
        " Entity(name='the Lotus menu command hierarchy', generic=True, plural=False)]"
       ]
      },
@@ -617,10 +606,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from authorityspoke import Entity, Association\n",
+    "from authorityspoke import Entity\n",
     "\n",
     "nosferatu_rule = lotus_majority.holdings[0].new_context(\n",
-    "    {Association('Borland International'): Association('Prana Film'),\n",
+    "    {Entity('Borland International'): Entity('Prana Film'),\n",
     "    Entity('the Lotus menu command hierarchy'): Entity(\"Dracula\")}\n",
     ")"
    ]

diff --git a/tests/conftest.py b/tests/conftest.py
@@ -5,7 +5,6 @@
 
 from authorityspoke.factors import Factor, Entity
 from authorityspoke.enactments import Code, Enactment
-from authorityspoke.entities import Event, Human
 from authorityspoke.factors import Evidence, Exhibit
 from authorityspoke.factors import Fact
 from authorityspoke.jurisdictions import Jurisdiction, Regime
@@ -20,17 +19,17 @@ def make_entity() -> Dict[str, Entity]:
     return {
         "motel": Entity("Hideaway Lodge"),
         "motel_specific": Entity("Hideaway Lodge", generic=False),
-        "watt": Human("Wattenburg"),
+        "watt": Entity("Wattenburg"),
         "trees": Entity("the stockpile of trees"),
         "trees_specific": Entity("the stockpile of trees", generic=False),
-        "tree_search": Event("officers' search of the stockpile of trees"),
-        "tree_search_specific": Event(
+        "tree_search": Entity("officers' search of the stockpile of trees"),
+        "tree_search_specific": Entity(
             "officers' search of the stockpile of trees", generic=False
         ),
-        "alice": Human("Alice"),
-        "bob": Human("Bob"),
-        "craig": Human("Craig"),
-        "dan": Human("Dan"),
+        "alice": Entity("Alice"),
+        "bob": Entity("Bob"),
+        "craig": Entity("Craig"),
+        "dan": Entity("Dan"),
         "circus": Entity("circus"),
     }
 

diff --git a/tests/test_enactments.py b/tests/test_enactments.py
@@ -5,7 +5,6 @@
 from pint import UnitRegistry
 import pytest
 
-from authorityspoke.entities import Human, Event
 from authorityspoke.enactments import Code, Enactment
 from authorityspoke.opinions import Opinion
 from authorityspoke.predicates import ureg, Q_

diff --git a/tests/test_entities.py b/tests/test_entities.py
@@ -7,7 +7,6 @@
 
 from authorityspoke.factors import Entity
 from authorityspoke.factors import Predicate, Factor, Fact
-from authorityspoke.entities import Human
 from authorityspoke.opinions import Opinion
 from authorityspoke.predicates import ureg, Q_
 
@@ -30,20 +29,20 @@ def test_repr_equal_after_make_generic(self, make_entity):
 
     def test_context_register(self, make_entity):
         """
-        Class "Human" implies "Entity" but not vice versa.
+        There will be a match because both object are :class:`.Entity`.
         """
         motel = make_entity["motel"]
         watt = make_entity["watt"]
-        empty_update = motel._context_register(watt, operator.ge)
-        assert not any(register is not None for register in empty_update)
+        update = motel._context_register(watt, operator.ge)
+        assert any(register is not None for register in update)
 
         update = motel._context_register(watt, operator.le)
         assert any(register == {motel: watt, watt: motel} for register in update)
 
     def test_new_context(self, make_entity):
         changes = {
             make_entity["motel"]: Entity("Death Star"),
-            make_entity["watt"]: Human("Darth Vader"),
+            make_entity["watt"]: Entity("Darth Vader"),
         }
         motel = make_entity["motel"]
         assert motel.new_context(changes) == changes[make_entity["motel"]]
@@ -62,14 +61,6 @@ def test_equality_generic_entities(self, make_entity):
         assert e["motel"].means(e["trees"])
         assert not e["motel"] == e["trees"]
 
-    def test_generic_human_and_event_not_equal(self, make_entity):
-        """Neither is a subclass of the other."""
-        assert not make_entity["tree_search"].means(make_entity["watt"])
-
-    def test_generic_human_and_entity_not_equal(self, make_entity):
-        """Human is a subclass of Entity."""
-        assert not make_entity["motel"].means(make_entity["watt"])
-
     # Implication
 
     def test_implication_generic_entities(self, make_entity):
@@ -87,9 +78,6 @@ def test_implication_subclass(self, make_entity):
         assert make_entity["tree_search_specific"] >= make_entity["motel"]
         assert make_entity["tree_search"] > make_entity["motel"]
 
-    def test_implication_superclass(self, make_entity):
-        assert not make_entity["trees"] >= make_entity["tree_search"]
-
     # Contradiction
 
     def test_error_contradiction_with_non_factor(self, make_entity, make_predicate):

diff --git a/tests/test_factors.py b/tests/test_factors.py
@@ -4,7 +4,6 @@
 import pytest
 
 from authorityspoke.factors import Entity, Factor, Fact, means
-from authorityspoke.entities import Human
 from authorityspoke.rules import Rule, ProceduralRule
 from authorityspoke.opinions import Opinion
 from authorityspoke.predicates import ureg, Q_
@@ -95,7 +94,7 @@ def test_string_representation_with_concrete_entities(self, watt_factor):
 
     def test_new_context_replace_fact(self, make_entity, watt_factor):
         changes = {
-            make_entity["watt"]: Human("Darth Vader"),
+            make_entity["watt"]: Entity("Darth Vader"),
             watt_factor["f2"]: watt_factor["f10"],
         }
         assert "was within the curtilage of <Hideaway Lodge>" in str(
@@ -108,7 +107,7 @@ def test_get_factor_from_recursive_search(self, make_opinion_with_holding):
         )
         factor = factor_list[1]
         assert any(
-            factor == Human("parole officer") and factor.name == "parole officer"
+            factor == Entity("parole officer") and factor.name == "parole officer"
             for factor in factor_list
         )
 
@@ -198,16 +197,14 @@ def test_standard_of_proof_in_str(self, watt_factor):
         factor = watt_factor["f2_preponderance_of_evidence"]
         assert factor.standard_of_proof in str(factor)
 
-    def test_context_register_empty(self, watt_factor):
+    def test_context_register_empty(self, make_complex_fact, watt_factor):
         """
         Yields no context_register because the Entity in f1 doesn't imply
-        the Human in f1_entity_order.
+        the Fact in f_relevant_murder.
         """
         with pytest.raises(StopIteration):
             next(
-                watt_factor["f1"]._context_registers(
-                    watt_factor["f1_entity_order"], operator.ge
-                )
+                watt_factor["f1"]._context_registers(make_complex_fact["f_relevant_murder"], operator.ge)
             )
 
     def test_context_register_valid(self, make_entity, watt_factor):

diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py
@@ -4,7 +4,6 @@
 """
 
 from authorityspoke import Enactment, Entity
-from authorityspoke.entities import Association
 from authorityspoke.selectors import TextQuoteSelector
 
 
@@ -21,7 +20,7 @@ def test_replace_generic_factor(self, make_opinion_with_holding):
         lotus_majority = make_opinion_with_holding["lotus_majority"]
         nosferatu_rule = lotus_majority.holdings[0].new_context(
             {
-                Association("Borland International"): Association("Prana Film"),
+                Entity("Borland International"): Entity("Prana Film"),
                 Entity("the Lotus menu command hierarchy"): Entity("Dracula"),
             }
         )

diff --git a/tests/test_rules.py b/tests/test_rules.py
@@ -2,7 +2,6 @@
 import pytest
 
 from authorityspoke.enactments import Code, Enactment
-from authorityspoke.entities import Human
 from authorityspoke.factors import Predicate, Entity, Factor, Fact
 from authorityspoke.factors import Evidence, Exhibit
 from authorityspoke.rules import Procedure, Rule, ProceduralRule
@@ -26,7 +25,7 @@ def test_None_not_in_str(self, make_holding):
 
     def test_new_concrete_context(self, make_holding):
         different = make_holding["h1"].new_context(
-            [Entity("Castle Grayskull"), Human("He-Man")]
+            [Entity("Castle Grayskull"), Entity("He-Man")]
         )
         assert "<He-Man> operated" in str(different)