add files

Author: davidsketchdeck

Pipfile

@@ -0,0 +1,14 @@
+[[source]]
+
+url = "https://pypi.python.org/simple"
+verify_ssl = true
+name = "pypi"
+
+
+[packages]
+
+"neo4j-driver" = "*"
+numpy = "*"
+
+[dev-packages]
+

basic_types/__init__.py

@@ -0,0 +1 @@
+from .nano_type import NanoType, NanoID

basic_types/nano_type.py

@@ -0,0 +1,47 @@
+from typing import Generic, TypeVar
+from uuid import uuid4, UUID
+
+T = TypeVar('T')
+
+
+class NanoType(Generic[T]):
+    def __init__(self, value: [T]):
+        self._value: T = value
+
+    @property
+    def value(self) -> T:
+        return self._value
+
+    def __hash__(self):
+        return self._value.__hash__()
+
+    def __eq__(self, other):
+        if isinstance(other, NanoType):
+            return self._value.__eq__(other._value)
+        return self._value.__eq__(other)
+
+    def __ne__(self, other):
+        return self._value.__ne__(other)
+
+    def __gt__(self, other):
+        return self._value.__gt__(other)
+
+    def __lt__(self, other):
+        return self._value.__lt__(other)
+
+    def __str__(self):
+        return str(self.value)
+
+    def __repr__(self):
+        return str(self.value)
+
+
+class NanoID(NanoType[UUID]):
+
+    @property
+    def id(self) -> NanoType:
+        return self
+
+    @classmethod
+    def new_random(cls):
+        return cls(uuid4())

config/.gitignore

@@ -0,0 +1 @@
+local*

config/__init__.py

@@ -0,0 +1,44 @@
+from collections import defaultdict
+from .environment import Environment
+
+# There are too many layers and too many files to this config system
+default_values = {
+    'neo4j_url': 'bolt://localhost',
+    'neo4j_user': 'neo4j',
+    'neo4j_password': 'local neo hates security!'
+}
+
+environment_box = Environment(None)
+
+
+def set_environment(environment_name):
+    environment_box.name = environment_name
+
+
+def get(config_variable_name):
+    # don't execute code in overrides till necessary
+    from .overrides import overrides
+    return overrides[environment_box.name].get(config_variable_name, default_values[config_variable_name])
+
+
+class Config(object):
+    @property
+    def neo4j_url(self):
+        return get('neo4j_url')
+
+    @property
+    def neo4j_user(self):
+        return get('neo4j_user')
+
+    @property
+    def neo4j_password(self):
+        return get('neo4j_password')
+
+
+config: Config = Config()
+
+import os
+
+if 'ENVIRONMENT' not in os.environ:
+    raise Exception("You must set an ENVIRONMENT variable. Sorry, I am very opinionated that we should not have a default value because it will mask misconfiguration issues later.")
+set_environment(os.environ['ENVIRONMENT'])

config/environment.py

@@ -0,0 +1,3 @@
+class Environment(object):
+    def __init__(self, name):
+        self.name = name

config/overrides.py

@@ -0,0 +1,22 @@
+import json
+overrides = dict()
+
+# There are too many layers and too many files to this config system
+overrides.update(**{
+    'remote': {
+        'neo4j_url': 'bolt://796bafef-staging.databases.neo4j.io',
+        'neo4j_user': 'readonly',
+        'neo4j_password': '0s3DGA6Zq'
+    },
+    'floyd': { # Todo: implement me?
+        'neo4j_url': 'bolt://796bafef-staging.databases.neo4j.io',
+        'neo4j_user': 'readonly',
+        'neo4j_password': '0s3DGA6Zq'
+    },
+    'local': { # Just uses defaults
+
+    }
+})
+
+with open('./config/local_overrides.json') as f:
+    overrides.update(json.load(f))

data_sets/__init__.py

@@ -0,0 +1 @@
+from .synthetic_review_prediction import runner

data_sets/synthetic_review_prediction/.DS_Store

@@ -0,0 +1,2 @@
+# Synthetic Review Prediction
+

data_sets/synthetic_review_prediction/README.md

@@ -0,0 +1,16 @@
+
+# TODO: create a decorator to do this for us
+from .article_0 import runner as article_0_runner
+from .experiment_1 import runner as experiment_1_runner
+from .experiment_2 import runner as experiment_2_runner
+from .experiment_3 import runner as experiment_3_runner
+from .experiment_4 import runner as experiment_4_runner
+from .experiment_5 import runner as experiment_5_runner
+
+runner = dict()
+runner.update(article_0_runner)
+runner.update(experiment_1_runner)
+runner.update(experiment_2_runner)
+runner.update(experiment_3_runner)
+runner.update(experiment_4_runner)
+runner.update(experiment_5_runner)

data_sets/synthetic_review_prediction/__init__.py

@@ -0,0 +1,11 @@
+from .configure import DATASET_NAME, create_data_set_properties
+from .generate import run as _run
+
+
+def run(client):
+    print(DATASET_NAME)
+    return _run(client, create_data_set_properties())
+
+runner = {
+	DATASET_NAME: run
+}

data_sets/synthetic_review_prediction/article_0/__init__.py

@@ -0,0 +1,43 @@
+from ..meta_classes import DataSetProperties
+from ..meta_classes.data_set_properties import PersonStyleWeightDistribution, PersonStyleWeight, ProductStyleWeight
+from ..utils import WeightedOption, Distribution
+from ..classes import PersonStylePreferenceEnum, ProductStyleEnum, Style
+from ..experiment_1.opinion_function import opinion_function
+from ..experiment_1.style_functions import person_style_function, product_style_function
+from graph_io.classes.dataset_name import DatasetName
+
+DATASET_NAME = DatasetName('article_0')
+
+
+def create_data_set_properties() -> DataSetProperties:
+    N_STYLES = 2
+    styles = [Style(str(i)) for i in range(N_STYLES)]
+
+    for style in styles:
+        ProductStyleEnum.register('LIKES_STYLE_'+style.value, style)
+        PersonStylePreferenceEnum.register('HAS_STYLE_'+style.value, style)
+
+    data_set_properties = DataSetProperties(
+        dataset_name=DATASET_NAME,
+        n_reviews=20000,
+        reviews_per_product=10,
+        reviews_per_person_distribution=[
+            WeightedOption[int](1, 0.25),
+            WeightedOption[int](2, 0.25),
+            WeightedOption[int](3, 0.25),
+            WeightedOption[int](4, 0.25)
+        ],
+        person_styles_distribution=PersonStyleWeightDistribution([
+            PersonStyleWeight(x, 1) for x in PersonStylePreferenceEnum.iterate()
+        ]),
+        product_styles_distribution=Distribution[ProductStyleWeight, ProductStyleEnum]([
+            ProductStyleWeight(x, 1) for x in ProductStyleEnum.iterate()
+        ]),
+        opinion_function=opinion_function,
+        person_style_function=person_style_function,
+        product_style_function=product_style_function,
+        n_companies=0,
+        person_company_number_of_relationships_distribution=[]
+    )
+
+    return data_set_properties

data_sets/synthetic_review_prediction/article_0/configure.py

@@ -0,0 +1,37 @@
+from ..classes import PersonWroteReview, ReviewOfProduct, IsGoldenFlag
+import random
+
+from ..meta_classes import DataSetProperties
+from ..experiment_1.simple_data_set import SimpleDataSet
+from ..utils import DatasetWriter
+from graph_io import QueryParams, CypherQuery
+
+
+def run(client, data_set_properties: DataSetProperties):
+
+    with DatasetWriter(client, data_set_properties.dataset_name, {"is_golden",""}) as writer:
+
+        writer.nuke_dataset()
+
+        data_set: SimpleDataSet = SimpleDataSet(data_set_properties)
+
+        def create_indexes():
+            client.execute_cypher_write(CypherQuery("CREATE INDEX ON :NODE(id)"), QueryParams())
+            #client.execute_cypher_write(CypherQuery("CREATE INDEX ON :NODE(id, dataset_name)"), QueryParams())
+            pass
+
+        create_indexes()
+
+        for i, product in enumerate(data_set.generate_public_products()):
+            writer.create_node_if_not_exists(product, {"style"})
+
+        for i, person in enumerate(data_set.generate_public_people()):
+            writer.create_node_if_not_exists(person, {"style_preference"})
+
+            for review in data_set.generate_reviews(person):
+                review.test = random.random() <= 0.1
+                writer.create_node_if_not_exists(review, {"score", "test"})
+                writer.create_edge_if_not_exists(PersonWroteReview(review.by_person, review.id, IsGoldenFlag(False)), set())
+                writer.create_edge_if_not_exists(ReviewOfProduct(review.id, review.of_product, IsGoldenFlag(False)), set())
+
+

data_sets/synthetic_review_prediction/article_0/generate.py

@@ -0,0 +1,22 @@
+# Extending the type system of python
+from .dynamic_enum import DynamicEnum
+
+# Primitives (TODO: do these need to be exposed?)
+from .golden_flag import IsGoldenFlag
+from .graph_node import GraphNode
+from graph_io.classes.dataset_name import DatasetName
+from .graph_edge import GraphEdge
+
+# Enum Types within our business logic
+from .style import Style
+
+# Node Types within our business logic
+from .company import CompanyID, Company
+from .product import ProductID, Product, ProductStyle, ProductStyleEnum, ProductStyleVector
+from .person import PersonID, Person, PersonMetaProperties, PersonStylePreference, PersonStylePreferenceEnum, PersonStylePreferenceVector
+from .review import Review, ReviewScore, ReviewID
+
+# Edge Types within our business logic
+from .person_opinion_company import PersonHatesCompany, PersonLikesCompany
+from .person_wrote_review import PersonWroteReview, ReviewOfProduct
+

data_sets/synthetic_review_prediction/classes/__init__.py

@@ -0,0 +1,17 @@
+from uuid import UUID, uuid4
+from .graph_node import NodeLabel, GraphNodeIdentifier, GraphNode, IsGoldenFlag
+from basic_types import NanoType, NanoID
+from .style import Style
+from .dynamic_enum import DynamicEnum
+
+
+class CompanyID(GraphNodeIdentifier):
+    LABEL = NodeLabel('Company')
+
+    def __init__(self, _id: UUID):
+        super().__init__(self.LABEL, _id)
+
+
+class Company(GraphNode[CompanyID]):
+    pass
+