kosh 3.4__tar.gz → 3.5__tar.gz

{kosh-3.4/kosh.egg-info → kosh-3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kosh
-Version: 3.4
+Version: 3.5
 Summary: Manages Data Store with External Bulk Data
 Author: Charles Doutriaux, Renee Olson
 License: MIT

kosh-3.5/kosh/current_version.py

@@ -0,0 +1 @@
+current_version = "3.5"

{kosh-3.4 → kosh-3.5}/kosh/dataset.py

@@ -1463,7 +1463,7 @@ class KoshDataset(KoshSinaObject):
         return attributes
 
     @lock_strategies.lock_method
-    def to_dataframe(self, data_columns=[], *atts, **keys):
+    def to_dataframe(self, data_columns=[], typed_columns=None, *atts, **keys):
         """Return the find object as a Pandas DataFrame.
 
         Pass in the same arguments and keyword arguments as the find method.
@@ -1482,6 +1482,39 @@ class KoshDataset(KoshSinaObject):
         :param data_columns: Columns to extract. By default this will include ['id', 'mime_type', 'uri', 'associated'].
                             If nothing is passed, will return all data.
         :type data_columns: Union(str, list), optional
+        :param typed_columns: Dictionary of column types and replacement values.
+            If omitted, MySQL defaults are returned.
+
+            Supported types:
+                [
+                    "Int8", "Int16", "Int32", "Int64",
+                    "UInt8", "UInt16", "UInt32", "UInt64",
+                    "float16", "float32", "float64",
+                    "Float32", "Float64",
+                    "bool", "boolean", "string", "object",
+                    "category", "datetime64[ns]", "timedelta64[ns]",
+                ]
+
+            Example:
+                {
+                    "my_int": {
+                        "type": "Int64",
+                        "replace": {None: 42},
+                    },
+                    "my_float": {
+                        "type": "float64",
+                        "replace": {None: np.nan, 999: -1},
+                    },
+                    "my_boolean": {
+                        "type": "boolean",
+                        "replace": {None: False},
+                    },
+                    "my_string": {
+                        "type": "string",
+                        "replace": {"This is empty": "Nothing Here"},
+                    },
+                }
+        :type typed_columns: dict, optional
         :return: Pandas DataFrame
         :rtype: Pandas DataFrame
         """
@@ -1522,4 +1555,14 @@ class KoshDataset(KoshSinaObject):
                     attr_dict[column][i] = source['data'].get(column, {}).get('value', pd.NA)
 
         df = pd.DataFrame(attr_dict)
+
+        if isinstance(typed_columns, dict):
+            for key, config in typed_columns.items():
+                series = df[key]
+
+                if "replace" in config:
+                    series = series.replace(config["replace"]).infer_objects(copy=False)
+
+                df[key] = series.astype(config["type"])
+
         return df

{kosh-3.4 → kosh-3.5}/kosh/ensemble.py

@@ -337,7 +337,7 @@ These datasets will inherit attributes and associated sources from the ensemble.
 
     @lock_strategies.lock_method
     def to_dataframe(self, data_columns=[], include_ensemble_attributes=True, include_ensemble_tags=True,
-                     *atts, **keys):
+                     typed_columns=None, *atts, **keys):
         """Return the find_datasets object as a Pandas DataFrame.
 
         Pass in the same arguments and keyword arguments as the find method.
@@ -362,6 +362,39 @@ These datasets will inherit attributes and associated sources from the ensemble.
         :type include_ensemble_attributes: bool, optional
         :param include_ensemble_tags: Include ensemble tags in DataFrame.
         :type include_ensemble_tags: bool, optional
+        :param typed_columns: Dictionary of column types and replacement values.
+            If omitted, MySQL defaults are returned.
+
+            Supported types:
+                [
+                    "Int8", "Int16", "Int32", "Int64",
+                    "UInt8", "UInt16", "UInt32", "UInt64",
+                    "float16", "float32", "float64",
+                    "Float32", "Float64",
+                    "bool", "boolean", "string", "object",
+                    "category", "datetime64[ns]", "timedelta64[ns]",
+                ]
+
+            Example:
+                {
+                    "my_int": {
+                        "type": "Int64",
+                        "replace": {None: 42},
+                    },
+                    "my_float": {
+                        "type": "float64",
+                        "replace": {None: np.nan, 999: -1},
+                    },
+                    "my_boolean": {
+                        "type": "boolean",
+                        "replace": {None: False},
+                    },
+                    "my_string": {
+                        "type": "string",
+                        "replace": {"This is empty": "Nothing Here"},
+                    },
+                }
+        :type typed_columns: dict, optional
         :return: Pandas DataFrame
         :rtype: Pandas DataFrame
         """
@@ -425,4 +458,14 @@ These datasets will inherit attributes and associated sources from the ensemble.
                 attr_dict[f"{self.id}_ENSEMBLE_ATTRIBUTE_{key}"] = [val] * total_datasets
 
         df = pd.DataFrame(attr_dict)
+
+        if isinstance(typed_columns, dict):
+            for key, config in typed_columns.items():
+                series = df[key]
+
+                if "replace" in config:
+                    series = series.replace(config["replace"]).infer_objects(copy=False)
+
+                df[key] = series.astype(config["type"])
+
         return df

{kosh-3.4 → kosh-3.5}/kosh/store.py

@@ -2307,7 +2307,7 @@ class KoshStore(object):
         KoshCmd._tar(self, tar_type, store_args=cmmd, opts=opts)
 
     @lock_strategies.lock_method
-    def to_dataframe(self, data_columns=[], *atts, **keys):
+    def to_dataframe(self, data_columns=[], typed_columns=None, *atts, **keys):
         """Return the find object as a Pandas DataFrame.
 
         Pass in the same arguments and keyword arguments as the find method.
@@ -2328,6 +2328,39 @@ class KoshStore(object):
                                                                                'creation_date', 'last_modified_date'].
                              If nothing is passed, will return all data.
         :type data_columns: Union(str, list), optional
+        :param typed_columns: Dictionary of column types and replacement values.
+            If omitted, MySQL defaults are returned.
+
+            Supported types:
+                [
+                    "Int8", "Int16", "Int32", "Int64",
+                    "UInt8", "UInt16", "UInt32", "UInt64",
+                    "float16", "float32", "float64",
+                    "Float32", "Float64",
+                    "bool", "boolean", "string", "object",
+                    "category", "datetime64[ns]", "timedelta64[ns]",
+                ]
+
+            Example:
+                {
+                    "my_int": {
+                        "type": "Int64",
+                        "replace": {None: 42},
+                    },
+                    "my_float": {
+                        "type": "float64",
+                        "replace": {None: np.nan, 999: -1},
+                    },
+                    "my_boolean": {
+                        "type": "boolean",
+                        "replace": {None: False},
+                    },
+                    "my_string": {
+                        "type": "string",
+                        "replace": {"This is empty": "Nothing Here"},
+                    },
+                }
+        :type typed_columns: dict, optional
         :return: Pandas DataFrame
         :rtype: Pandas DataFrame
         """
@@ -2365,4 +2398,14 @@ class KoshStore(object):
                     attr_dict[column][i] = dataset['data'].get(column, {}).get('value', pd.NA)
 
         df = pd.DataFrame(attr_dict)
+
+        if isinstance(typed_columns, dict):
+            for key, config in typed_columns.items():
+                series = df[key]
+
+                if "replace" in config:
+                    series = series.replace(config["replace"]).infer_objects(copy=False)
+
+                df[key] = series.astype(config["type"])
+
         return df

{kosh-3.4 → kosh-3.5/kosh.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kosh
-Version: 3.4
+Version: 3.5
 Summary: Manages Data Store with External Bulk Data
 Author: Charles Doutriaux, Renee Olson
 License: MIT

{kosh-3.4 → kosh-3.5}/kosh.egg-info/SOURCES.txt

@@ -57,6 +57,18 @@ kosh/transformers/npy.py
 kosh/transformers/sidre.py
 kosh/transformers/skl.py
 kosh/transformers/utils.py
+kosh_aml_files/dead/cassandra/__init__.py
+kosh_aml_files/dead/cassandra/core.py
+kosh_aml_files/dead/cassandra/init_casandra.py
+kosh_aml_files/dead/cassandra/models.py
+kosh_aml_files/dead/tests/cassandra/test_kosh_00.py
+kosh_aml_files/dead/tests/cassandra/test_kosh_01.py
+kosh_aml_files/dead/tests/cassandra/test_kosh_02.py
+kosh_aml_files/dead/tests/cassandra/test_kosh_03.py
+kosh_aml_files/dead/tests/sina/test_kosh_00.py
+kosh_aml_files/dead/tests/sina/test_kosh_01.py
+kosh_aml_files/dead/tests/sina/test_kosh_02.py
+kosh_aml_files/dead/tests/sina/test_kosh_03.py
 scripts/render_logos.py
 scripts/sbang
 tests/conftest.py

{kosh-3.4 → kosh-3.5}/kosh.egg-info/top_level.txt

@@ -1,11 +1,8 @@
-21742
-23834
-33823
-43672
 dist
 docs
 examples
 kosh
+kosh_aml_files
 recipe
 scripts
 share

kosh-3.5/kosh_aml_files/dead/cassandra/__init__.py

@@ -0,0 +1 @@
+from .core import KoshStoreCassandra, KoshArrayCassandra, KoshConnect

kosh-3.5/kosh_aml_files/dead/cassandra/core.py

@@ -0,0 +1,329 @@
+# Cassandra implementation
+from kosh.core import KoshStoreClass, KoshDataset, KoshArray
+import cassandra
+from cassandra.cluster import Cluster, Session
+from cassandra.auth import PlainTextAuthProvider
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine import connection, columns
+from cassandra.cqlengine.management import sync_table
+from cassandra.util import uuid_from_time
+from cassandra.query import BatchStatement, ConsistencyLevel
+from .models import DataSetModel, UsersModel, MetadataModel, types_mapping
+from collections import OrderedDict
+import warnings
+import time
+import uuid
+import numpy
+
+
+types = {"dataset": 0, "array": 1, "image": 2}
+
+
+class KoshCassandraObject(object):
+    def __init__(self, Id, koshType, protected=[]):
+        self.__dict__["__protected__"] = [
+            "__id__", "__type__", "__protected__"] + protected
+        self.__dict__["__id__"] = Id
+        self.__dict__["__type__"] = koshType
+
+    def __setattr__(self, name, value):
+        if name in self.__protected__:
+            self.__dict__[name] = value
+            return
+        exists = MetadataModel.objects(
+            id=self.__id__, id_type=self.__type__, name=name)
+        if exists.count() != 0:
+            # we need to drop it first, replacing
+            for e in exists:
+                e.delete()
+        MetadataModel.create(
+            id=self.__id__, id_type=self.__type__, name=name, value=repr(value))
+
+    def __getattr__(self, name):
+        if name in self.__dict__["__protected__"]:
+            return self.__dict__.get(name)
+        if name == "__attributes__":
+            return self.__getattributes__()
+
+        exists = MetadataModel.objects(
+            id=self.__id__, id_type=self.__type__, name=name)
+        if exists.count() == 0:
+            raise RuntimeError(
+                "Object {} does not have {} attribute".format(self.__id__, name))
+        return eval(exists[0].value)
+
+    def __delattr__(self, name):
+        if name in self.__protected__:
+            return
+        exists = MetadataModel.objects(
+            id=self.__id__, id_type=self.__type__, name=name)
+        if exists.count() == 0:
+            raise RuntimeError(
+                "Object {} does not have {} attribute".format(self.__id__, name))
+        exists[0].delete()
+
+    def listattributes(self):
+        exists = MetadataModel.objects(id=self.__id__, id_type=self.__type__)
+        attributes = []
+        for e in exists:
+            attributes.append(e.name)
+        return attributes
+
+    def __getattributes__(self):
+        exists = MetadataModel.objects(id=self.__id__, id_type=self.__type__)
+        attributes = {}
+        for e in exists:
+            attributes[e.name] = eval(e.value)
+        return attributes
+
+
+class KoshConnect(object):
+    def __init__(self, username, token, keyspace=None, cluster=[
+                 "sonar8", ], auth_provider=None, cassandraRoot="kosh"):
+        # This allows me to have test tables, etc...
+        self.__cassandraRoot__ = cassandraRoot
+        print("Connecting")
+        self.connect(username, token, keyspace, cluster, auth_provider)
+
+    def connect(self, username, token, keyspace=None,
+                cluster_names=["sonar8", ], auth_provider=None):
+        """ Connect to a cassandra database """
+        from cassandra.cluster import Cluster, Session
+        if auth_provider is None:
+            print("CREATING AUTH", username, token)
+            from cassandra.auth import PlainTextAuthProvider
+            auth_provider = PlainTextAuthProvider(
+                username=username, password=token)
+
+        if not isinstance(cluster_names, list):
+            cluster_names = [cluster_names, ]
+        # print("CLUSTER TO:", cluster_names)
+        cluster = Cluster(cluster_names, auth_provider=auth_provider)
+        if keyspace is None:
+            keyspace = username + "_k"
+        # print("KSPACE:", keyspace)
+        self.__session__ = cluster.connect(keyspace)
+        # print("CONNECTED TO:", self.__session__, auth_provider.username, auth_provider.password)
+        self.__username__ = username
+        connection.setup(cluster_names, default_keyspace=keyspace,
+                         auth_provider=auth_provider)
+        for obj in [DataSetModel, UsersModel, MetadataModel]:
+            obj.__keyspace__ = self.__session__.keyspace
+            obj.__table_name__ = "{}_{}".format(
+                self.__cassandraRoot__, obj.__table_suffix__)
+            sync_table(obj)
+        self.__user_id__ = UsersModel.objects(name=self.__username__)[0].id
+        # self.prepared = {}
+        # self.prepared["datasetids"] = self.session.prepare("SELECT id from {}_datasets".format(self.cassandraRoot))
+        # self.prepared["metadata"] = self.session.prepare("SELECT * from {}_metadata where id=? and id_type=?".format(self.cassandraRoot))
+
+    def __del__(self):
+        # when destroying let's shutdown Cassandra cluster
+        # print("Shutting down Cassandra Cluster")
+        self.__session__.cluster.shutdown()
+        del(self.__session__)
+
+
+class KoshArrayCassandra(KoshConnect, KoshCassandraObject, KoshArray):
+    def __init__(self, Id, dimensions, username, token, keyspace=None, cluster=[
+                 "sonar8", ], auth_provider=None, cassandraRoot="kosh"):
+        """ Create a Casandra-based array, needs a connection to a cassandra database for metadata
+
+        Id: can be set to None to indicate new/inexisting array, otherwise point to array to read/extend
+        dimensions: ignored if array already exists, otherwise dictionary with dimension names as keys and metadata as dictinoary value
+        """
+        if Id is None:  # New array?
+            Id = uuid.uuid1().hex
+
+        KoshCassandraObject.__init__(self, Id, types["array"], protected=[
+            "__name__", "__creator__", "__type__", "__dims__",
+            "__session__", "__username__", "__cassandraRoot__",
+            "__table_id__", "__user_id__",
+            "__readers__", "__exporters__"])
+
+        KoshConnect.__init__(
+            self,
+            username,
+            token,
+            keyspace,
+            cluster,
+            auth_provider,
+            cassandraRoot)
+
+        self.__type__ = types["array"]
+        # Ok now create associted table, based on dimensions
+        self.__table_id__ = "{}_array_{}".format(self.__cassandraRoot__, Id)
+
+        dims = []
+        primary = []
+        if isinstance(dimensions, (list, tuple)):
+            tmp = OrderedDict()
+            for d in dimensions:
+                tmp[d] = {}
+            dimensions = tmp
+        if not isinstance(dimensions, OrderedDict):
+            raise RuntimeError("'dimensions' must be list or ordered dict")
+        self.__dims__ = dimensions
+        for dim in dimensions:
+            dim_dict = dimensions[dim]
+            dim_type = dim_dict.get("type", "float")
+            if dim_dict.get("primary", False):
+                primary.append(dim)
+            dims += [dim + " " + dim_type]
+        if primary == []:
+            primary = dimensions.keys()
+        tables = self.__session__.cluster.metadata.keyspaces[self.__session__.keyspace].tables
+        dims.append("value float")
+        if not self.__table_id__ in tables:
+            self.__session__.execute("create table {}({}, primary key({}))".format(
+                self.__table_id__, ",".join(dims), ",".join(primary)))
+        # self.__ArrayModel__ = ArrayModel
+
+    def load_from_numpy(self, data, offsets=None):
+        dims = list(self.__dims__.keys()) + ["value", ]
+        print("DIMS:", dims)
+        vals = ["?", ] * len(dims)
+        ps = self.__session__.prepare(
+            "INSERT INTO {} ( {} ) VALUES ( {} )".format(
+                self.__table_id__, ",".join(dims), ",".join(vals)))
+        # Ok did user send us dimensions values?
+        for i, d in enumerate(self.__dims__):
+            if self.__dims__[d].get("values", None) is None:
+                self.__dims__[d]["values"] = list(range(data.shape[i]))
+
+        batch = BatchStatement(consistency_level=ConsistencyLevel.QUORUM)
+        for i in range(data.size):
+            values = list(numpy.unravel_index(i, data.shape))
+            values += [float(data.flat[i]), ]
+            if data.size < 65535:
+                batch.add(ps, values)
+            else:
+                self.__session__.execute_async(ps, values)
+        if data.size < 65535:
+            self.__session__.execute_async(batch)
+
+    def __getitem__(self, *args):
+        args = args[0]
+        dims = list(self.__dims__.keys())
+        values = []
+        for i in range(len(args)):
+            a = self.__dims__[dims[i]]["values"][args[i]]
+            vals = ", ".join([str(_) for _ in a])
+            cmd = dims[i] + " IN ( {} )".format(vals)
+            values.append(cmd)
+        stmnt = "SELECT value FROM " + self.__table_id__ + \
+            " WHERE " + " AND ".join(values) + ";"
+        return self.__session__.execute(stmnt)
+
+    def __str__(self):
+        st = ""
+        st += "KOSH Array\n"
+        st += "\tid: {}\n".format(self.__id__)
+        st += "\tdimensions:{}\n".format(self.__dims__)
+        atts = self.__attributes__
+        if len(atts) > 0:
+            st += "\n--- Attributes ---\n"
+            for a in atts:
+                st += "\t{}: {}\n".format(a, atts[a])
+        st += "DONE!"
+        return st
+
+
+class KoshDatasetCassandra(KoshDataset, KoshCassandraObject):
+    def __init__(self, Id):
+        KoshCassandraObject.__init__(self, Id, types["dataset"], protected=[
+            "__name__", "__creator__"])
+        ds = DataSetModel.objects(id=Id)[0]  # unique by design
+        self.__creator__ = ds.creator
+        self.__name__ = ds.name
+
+    def __str__(self):
+        st = ""
+        st += "KOSH DATASET\n"
+        st += "\tid: {}\n".format(self.__id__)
+        st += "\tname:{}\n".format(self.__name__)
+        st += "\tcreator: {}\n".format(self.__creator__)
+        atts = self.__attributes__
+        if len(atts) > 0:
+            st += "\n--- Attributes ---\n"
+            for a in atts:
+                st += "\t{}: {}\n".format(a, atts[a])
+        return st
+
+
+class KoshStoreCassandra(KoshConnect, KoshStoreClass):
+    def __name_value_search(self, name, value):
+        if isinstance(value, str):
+            value = "''{}''".format(value)
+        values = "(name, id_type, value) = ('{}',  {}, '{}' )".format(
+            name, types["dataset"], value)
+        stmnt = "select id from {}_metadata where {} allow filtering".format(
+            self.__cassandraRoot__, values)
+        print("STE:", stmnt)
+        rows = self.__session__.execute(stmnt)
+        return rows
+
+    def search(self, *atts, **keys):
+        """ Search cassandra for datasets matching some metadata
+        arguments are the metadata name we are looking for e.g search("attr1", "attr2")
+        you can further restrict by specifying exact value for a metadata via key=value
+        """
+        no_values = "name in ({}) and id_type={}".format(
+            ",".join(["'{}'".format(a) for a in atts]), types["dataset"])
+
+        if len(atts) == 0 and len(keys) == 0:
+            raise RuntimeError("You need to pass some search")
+
+        rows = self.__session__.execute(
+            "select id from {}_metadata where {} allow filtering".format(
+                self.__cassandraRoot__, no_values))
+        ids = set()
+        for row in rows:
+            ids.add(row.id)
+        # Need to "escape quotes"
+        for k in keys:
+            value = keys[k]
+            if not isinstance(value, (list, tuple)):
+                value = [value, ]
+            rows = []
+            for val in value:
+                rows += self.__name_value_search(k, val)
+            limited = set()
+            for row in rows:
+                if row.id in ids:
+                    limited.add(row.id)
+            for an_id in list(ids):
+                if not an_id in limited:
+                    ids.remove(an_id)
+
+        # Return the datasets
+        ds = []
+        for ds_id in ids:
+            ds.append(self.open(ds_id))
+        return ds
+
+    def open(self, id):
+        """Returns a dataset from Cassandra, based on its id"""
+        return KoshDatasetCassandra(id)
+
+    def create(self, name=None, id=None, metadata={}):
+        """create a new (possibly named) dataset"""
+        # existingDatasets = self.session.execute_async(self.prepared["datasetids"])
+        if id is None:
+            if name is None:
+                name = "Unnamed Dataset"
+            ds = DataSetModel.create(
+                id=uuid_from_time(
+                    time.time()),
+                name=name,
+                creator=self.__user_id__)
+        else:
+            ds = DataSetModel.objects(id=id)
+            if ds.count() == 0:
+                ds = DataSetModel.create(
+                    id=id, name=name, creator=self.__user_id__)
+            else:
+                raise RuntimeError(
+                    "Dataset Id {}, already exists, cannot create duplicate dataset".format(id))
+        ds = KoshDatasetCassandra(str(ds.id))
+        return ds

kosh-3.5/kosh_aml_files/dead/cassandra/init_casandra.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+
+import argparse
+from cassandra.cluster import Cluster, Session
+from cassandra.auth import PlainTextAuthProvider
+import os
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--user", default="cdoutrix", help="username to connect to cassandra")
+parser.add_argument("--token", default=None, help="token to log, will try to read from ${HOME}/.cassandra/cqlshrc")
+parser.add_argument("--keyspace", default=None, help="keyspace, will try to read from ${HOME}/.cassandra/cqlshrc")
+parser.add_argument("--cluster", default="sonar8", help="Cluster")
+parser.add_argument("--tables_root", default="kosh", help="root for tables names")
+args = parser.parse_args()
+
+token = args.token
+keyspace = args.keyspace
+with open(os.path.expanduser("~/.cassandra/cqlshrc")) as f:
+    lines = f.readlines()
+    if token is None:
+        token = lines[2].split("=", 0)[-1].strip()
+    if keyspace is None:
+        keyspace = lines[3].split("=")[1].strip()
+auth_provider = PlainTextAuthProvider(username=args.user, password=token)
+cluster = Cluster(args.cluster.split(),auth_provider=auth_provider, protocol_version=2)
+session = cluster.connect(keyspace)
+
+drop_commands = """
+drop table {root}_metadata
+drop table {root}_datasets
+drop table {root}_permissions
+drop table {root}_users
+drop table {root}_targets
+""".format(root=args.tables_root)
+
+create_commands = """
+create table {root}_metadata (id timeuuid , id_type int , name text, value text, primary key ((id), name, id_type, value))
+create index on {root}_metadata (name)
+create index on {root}_metadata (value)
+create index on {root}_metadata (id_type)
+create table {root}_datasets (id timeuuid, creator int, name text, primary key (id, creator))
+create table {root}_users(id int, name text, primary key (name, id))
+create table {root}_permissions(user_id int, resource_id text, resource_type int, permission int, primary key (user_id, resource_id, resource_type))
+create table {root}_targets(id timeuuid primary key, source_type int, source_parameters map<text, text>, target_url text)
+insert into {root}_users (id, name) values (0, '{user}')
+""".format(root=args.tables_root, user=args.user)
+for command in drop_commands.split("\n"):
+    if len(command)>0:
+        print("Executing:", command)
+        try:
+            session.execute(command)
+        except Exception:
+            pass
+
+# Now drop array tables
+tables = list(cluster.metadata.keyspaces[keyspace].tables.keys())
+for table in tables:
+    if table.startswith("{}_array".format(args.tables_root)):
+        try:
+            session.execute("drop table {}".format(table))
+        except Exception as err:
+            print("EEROR: ", err)
+            pass
+
+# Create tables
+for command in create_commands.split("\n"):
+    if len(command)>0:
+        print("Executing:", command)
+        session.execute(command)
+

kosh-3.5/kosh_aml_files/dead/cassandra/models.py

@@ -0,0 +1,32 @@
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine import columns
+import time
+
+types_mapping = {
+    "int": columns.Integer,
+    "text": columns.Text,
+    "uuid": columns.TimeUUID,
+    "float": columns.Float,
+}
+
+
+class DataSetModel(Model):
+    __table_suffix__ = "datasets"
+    id = columns.TimeUUID(primary_key=True)
+    creator = columns.Integer(required=True, primary_key=True)
+    name = columns.Text()
+
+
+class UsersModel(Model):
+    __table_suffix__ = "users"
+    name = columns.Text(primary_key=True, required=True)
+    id = columns.Integer(primary_key=True)
+
+
+class MetadataModel(Model):
+    __table_suffix__ = "metadata"
+    id = columns.TimeUUID(primary_key=True)
+
+    name = columns.Text(primary_key=True, required=True)
+    id_type = columns.Integer(primary_key=True)
+    value = columns.Text(primary_key=True)