underscorepy 0.9.0__tar.gz → 0.10.0__tar.gz

{underscorepy-0.9.0 → underscorepy-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: underscorepy
-Version: 0.9.0
+Version: 0.10.0
 Summary: _.py library
 Author-email: Matthew Shaw <mshaw.cx@gmail.com>
 License-Expression: MIT

{underscorepy-0.9.0 → underscorepy-0.10.0}/_/caches/memory.py

@@ -34,7 +34,7 @@ class Memory(_.caches.Cache):
             session_id = session['session_id']
         except KeyError:
             raise _.error('No session_id defined in session')
-        self.sessions[session_id] = json.dumps(session)
+        self.sessions[session_id] = _.json_encode(session)
 
     async def load_session(self, session_id):
         session = self.sessions.get(session_id, None)

{underscorepy-0.9.0 → underscorepy-0.10.0}/_/caches/redis.py

@@ -56,7 +56,7 @@ class Redis(_.caches.Cache):
         except KeyError:
             raise _.error('No session_id defined in session')
         async with self.redis.pipeline(transaction=True) as pipe:
-            await pipe.set(f'session/{session_id}', json.dumps(session))
+            await pipe.set(f'session/{session_id}', _.json_encode(session))
             await pipe.expire(f'session/{session_id}', self._expires * 3600)
             await pipe.execute()
 

{underscorepy-0.9.0 → underscorepy-0.10.0}/_/databases/__init__.py

@@ -7,6 +7,7 @@
 #
 
 import base64
+import datetime
 import io
 import logging
 import typing
@@ -48,6 +49,30 @@ class UInt64(sqlalchemy.types.TypeDecorator):
         return value + (1 << 64) if value < 0 else value
 
 
+class UTCDateTime(sqlalchemy.types.TypeDecorator):
+    '''timezone-aware datetime: TIMESTAMPTZ on Postgres, UTC without a zone on
+       SQLite, always returned in UTC with tzinfo set; naive values are UTC'''
+    impl     = sqlalchemy.DateTime(timezone=True)
+    cache_ok = True
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+        if value.tzinfo is None:
+            value = value.replace(tzinfo=datetime.timezone.utc)
+        value = value.astimezone(datetime.timezone.utc)
+        if dialect.name != 'postgresql':
+            value = value.replace(tzinfo=None)
+        return value
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return value
+        if value.tzinfo is None:
+            return value.replace(tzinfo=datetime.timezone.utc)
+        return value.astimezone(datetime.timezone.utc)
+
+
 class JSONArray(sqlalchemy.types.TypeDecorator):
     'list stored as JSON for databases without arrays, bytes as base64'
     impl     = sqlalchemy.JSON
@@ -176,6 +201,7 @@ class Database:
 
     # CREATE
     async def insert(self, *args):
+        _before_save(args)
         try:
             async with self.session() as session:
                 async with session.begin():
@@ -203,6 +229,7 @@ class Database:
 
     # UPDATE
     async def upsert(self, *args):
+        _before_save(args)
         async with self.session() as session:
             async with session.begin():
                 for obj in args:
@@ -223,6 +250,14 @@ class Database:
                     return results.rowcount
 
 
+def _before_save(records):
+    'let records prepare themselves, e.g. number their children, before an insert or merge'
+    for record in records:
+        hook = getattr(record, '_before_save', None)
+        if hook:
+            hook()
+
+
 def _plan_schema(conn, metadata):
     '''compare the database with the models using alembic autogenerate and split
        the changes into those that are safe to apply and those that may lose data'''

{underscorepy-0.9.0 → underscorepy-0.10.0}/_/handlers.py

@@ -13,7 +13,18 @@ import tornado.web
 import _
 
 
-class Template(tornado.web.RequestHandler):
+class Handler(tornado.web.RequestHandler):
+    '''base for _ handlers, writes dicts and lists as JSON with _.JSONEncoder so
+       records, bytes and datetimes can be written directly'''
+    def write(self, chunk):
+        if isinstance(chunk, (dict, list)):
+            self.set_header('Content-Type', 'application/json; charset=UTF-8')
+            # like tornado, escape </ so the JSON is safe inside a script tag
+            chunk = _.json_encode(chunk).replace('</', '<\\/')
+        super().write(chunk)
+
+
+class Template(Handler):
     def initialize(self, template='index', **kwds):
         self.kwds = kwds
         self.template = template + '.html'

{underscorepy-0.9.0 → underscorepy-0.10.0}/_/logins/__init__.py

@@ -6,7 +6,7 @@ import tornado.web
 import _
 
 
-class Login(tornado.web.RequestHandler):
+class Login(_.handlers.Handler):
     @classmethod
     async def _(cls, component_name, **kwds):
         # create a dynamic child class with kwds from the ini file
@@ -57,7 +57,7 @@ class Login(tornado.web.RequestHandler):
         self.redirect(url)
 
 
-class LoginPage(tornado.web.RequestHandler):
+class LoginPage(_.handlers.Handler):
     def initialize(self, template='login', **kwds):
         self.kwds = kwds
         self.template = template + '.html'
@@ -69,7 +69,7 @@ class LoginPage(tornado.web.RequestHandler):
         self.render(template, message=message, next_url=next_url, **self.kwds)
 
 
-class Logout(tornado.web.RequestHandler):
+class Logout(_.handlers.Handler):
     async def get(self):
         session_id = self.get_signed_cookie('session_id', max_age_days=1)
 

{underscorepy-0.9.0 → underscorepy-0.10.0}/_/logins/dblogin.py

@@ -32,8 +32,8 @@ class DbLogin(_.logins.Login):
                 raise _.error('dblogin requires a database to be specified')
         try:
             cls._db = _.databases[cls._database]
-        except AttributeError:
-            raise _.error('No database specified for %s', component_name)
+        except KeyError:
+            raise _.error('Unknown database "%s" for %s', cls._database, component_name) from None
 
         # if only one login specified use short argument
         prefix = f'{component_name}-' if len(_.config['logins']) > 1 else ''

underscorepy-0.10.0/_/records/Protobuf.proto

@@ -0,0 +1,32 @@
+syntax = "proto3";
+
+import "google/protobuf/descriptor.proto";
+
+
+extend google.protobuf.MessageOptions {
+    // name of an auto-increment primary key column, e.g. 'order_id'
+    string id         = 50001;
+    // no database table for the message
+    bool   no_table   = 50002;
+    // no REST handler for the message
+    bool   no_handler = 50003;
+    // 50004 was refs, replaced by the (ref) field option; don't reuse it
+}
+
+extend google.protobuf.FieldOptions {
+    // primary key column
+    bool   pkey       = 50001;
+    // kept in the message but not stored
+    bool   no_column  = 50002;
+    // unique column, or with (paired) a unique group of columns
+    bool   uniq       = 50003;
+    // NOT NULL, and refused before saving when unset
+    bool   required   = 50004;
+    // foreign key to "Table.column"
+    string ref        = 50005;
+    // group name; fields in the same group share one composite index,
+    // or a unique constraint when they are all (uniq), e.g. "geo"
+    string paired     = 50006;
+    // storage hint, "uuid" for a native UUID column on a string field
+    string subtype    = 50007;
+}

{underscorepy-0.9.0 → underscorepy-0.10.0}/_/records/__init__.py

@@ -17,6 +17,14 @@ import sqlalchemy.ext.asyncio
 import _
 
 
+def group_args(table, indexes, uniques):
+    '''__table_args__ for named groups of columns, {group: [column, ...]}, as
+       composite indexes and unique constraints'''
+    args = [sqlalchemy.Index(f'ix_{table}_{group}', *columns) for group,columns in indexes.items()]
+    args += [sqlalchemy.UniqueConstraint(*columns, name=f'uq_{table}_{group}') for group,columns in uniques.items()]
+    return tuple(args)
+
+
 class Record:
     @classmethod
     async def _(cls, component_name, **kwds):

{underscorepy-0.9.0 → underscorepy-0.10.0}/_/records/data.py

@@ -67,6 +67,8 @@ class Data(_.records.Record):
             cls = dataclasses.dataclass(init=False, kw_only=True)(cls)
 
         primary_key = None
+        # named groups of columns, {group: [column, ...]}
+        indexes,uniques = {},{}
         for field in dataclasses.fields(cls):
             # check if column should be primary key
             is_primary_key = field.metadata.get('pkey', False)
@@ -78,6 +80,14 @@ class Data(_.records.Record):
             uniq = field.metadata.get('uniq', False)
             refs = field.metadata.get('refs', None)
 
+            # uniq('geo') and paired('geo') group columns under a name
+            if isinstance(uniq, str):
+                uniques.setdefault(uniq, []).append(field.name)
+                uniq = False
+            paired = field.metadata.get('paired', None)
+            if paired:
+                indexes.setdefault(paired, []).append(field.name)
+
             if refs:
                 annotations[field.name] = sqlalchemy.orm.Mapped[typing.Optional[field.type]]
                 members[field.name] = sqlalchemy.orm.mapped_column(
@@ -102,6 +112,9 @@ class Data(_.records.Record):
                     init=False,
                     )
 
+        if indexes or uniques:
+            members['__table_args__'] = _.records.group_args(name, indexes, uniques)
+
         if primary_key is None:
             primary_key = f'{name}_id'
             members[primary_key] = sqlalchemy.orm.mapped_column(
@@ -140,7 +153,8 @@ class Data(_.records.Record):
             return
 
         types = [data_handler] if data_handler else [_.records.HandlerInterface]
-        types.append(tornado.web.RequestHandler)
+        # custom handlers get the JSON writing of the _ base handler
+        types.append(_.handlers.Handler)
 
         # served at the record name, whichever handler class is used
         handler_name = data_handler.__name__ if data_handler else name
@@ -225,7 +239,13 @@ class DataContainer(_.Container):
 
     @staticmethod
     def uniq(group=None, arg=dataclasses.MISSING):
-        return dataclasses.field(metadata={'uniq':True})
+        '''a unique column, or with a group name a unique group of columns'''
+        return dataclasses.field(metadata={'uniq':group or True})
+
+    @staticmethod
+    def paired(group):
+        '''columns given the same group name share one composite index'''
+        return dataclasses.field(metadata={'paired':group})
 
     @staticmethod
     def refs(table_column):