rattail/commands.make_appdir

   rattail/commands.typer

   rattail/config

   rattail/csvutil

   rattail/custorders

   rattail/datasync/index

   def do_stuff(config):

       from rattail.db import Session

       session = Session()

       print(session.query(model.Product).count())

        "texttable",

        "typer",

        "typing-extensions",

        "xlrd",

]

                          NOTSET)

from rattail.files import temp_path, resource_path

from rattail.mail import send_email

log = logging.getLogger(__name__)

    :meth:`~wuttjamaican:wuttjamaican.conf.WuttaConfig.get_app()` on

    the config object if you need the app handler.

    """

    default_autocompleters = {

        'brands': 'rattail.autocomplete.brands:BrandAutocompleter',

        'customers': 'rattail.autocomplete.customers:CustomerAutocompleter',

        """

        return self.config.get_enum()

    def get_node_title(self, default='Rattail'):

        """

        """

        import sqlalchemy as sa

        model = self.model

        return session.query(model.Store)\

                      .filter(sa.or_(

                          model.Store.archived == False,

                kwargs['dir'] = tmpdir

        return temp_path(**kwargs)

    def maxlen(self, attr):

        """

        Return the max size (length) for the given model attribute.

        self.app = self.config.get_app()

        self.enum = config.get_enum()

        try:

        except ImportError:

            pass

    def __init__(self, config, **kwargs):

        self.config = config

        self.app = self.config.get_app()

        self.enum = config.get_enum()

    @property

    def batch_model_class(self):

    """

    Returns the list of available batch type keys.

    """

    keys = []

    for name in dir(model):

        self.enum = config.get_enum()

        try:

        except ImportError:

            pass

    # TODO: what about web apps etc.? i guess i was only having the problem

    # for some importers, e.g. basic CORE API -> Rattail w/ the schema

    # extensions in place from rattail-corepos

    try:

    except ImportError:

        pass

    def get_model(self):

        """

        """

    def get_enum(self, **kwargs):

        """

    def __init__(self, config, key, **kwargs):

        self.config = config

        self.app = self.config.get_app()

        self.enum = self.config.get_enum()

        self.key = key

        self.prefix = kwargs.pop('prefix', key)

################################################################################

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

Core Stuff

"""

# Arbitrary object used to explicitly denote an unspecified value, e.g. for

def get_uuid():

    """

    """

        # maybe also look for config settings in DB

        if config.usedb:

            app = config.get_app()

            session = app.make_session()

            settings = session.query(model.Setting)\

                              .filter(model.Setting.name.like(f'rattail.datasync.{profile_key}.consumer.%.spec'))\

        # maybe also look for config settings in DB

        if config.usedb:

            app = config.get_app()

            session = app.make_session()

            settings = session.query(model.Setting)\

                              .filter(model.Setting.name.like('rattail.datasync.%.watcher.spec'))\

        self.dbkey = dbkey

        self.runas_username = runas

        self.watcher = watcher

        self.app = config.get_app()

    def setup(self):

        """

################################################################################

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

DataSync for Linux

"""

import sys

import time

import logging

       ``True`` if no error.

    """

    app = config.get_app()

    # if watcher consumes itself, then it will process its own

    # changes.  note that there are no assumptions made about the

    :returns: ``True`` if all goes well, ``False`` if error.

    """

    app = config.get_app()

    try:

        session = app.make_session()

    :returns: ``True`` if all goes well, ``False`` if error.

    """

    app = config.get_app()

    # we only want changes "obtained" at the given time.  however, at least

    # until all code has been refactored, we must take two possibilities into

    def __init__(self, *args, **kwargs):

        super().__init__(*args, **kwargs)

        self.engine = self.config.rattail_engines[self.dbkey]

    def get_changes(self, lastrun):

        """

        Subclasses may override this if they have extended the schema.

        Defaults to ``rattail.db.model``.

        """

    def process_changes(self, host_session, changes):

        """

    def __init__(self, *args, **kwargs):

        super().__init__(*args, **kwargs)

        self.target_engine = self.config.rattail_engines[self.dbkey]

    def make_target_session(self):

        return self.app.make_session(bind=self.target_engine)

        super().__init__(*args, **kwargs)

        self.host_engine = self.config.rattail_engines[self.watcher.dbkey]

        self.local_engine = self.config.rattail_engines[self.dbkey]

    def process_changes(self, session, changes):

        self.host_session = self.app.make_session(bind=self.host_engine)

################################################################################

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

import sqlalchemy as sa

    """

    Base class for all DataSync watchers.

    """

        self.key = key

        self.dbkey = dbkey

        self.delay = 1 # seconds

        self.app = self.config.get_app()

    def setup(self):

        """

        "other" server.

        """

        # get current time according to "other" server, and convert to UTC

        other_now = session.execute(sa.text('select current_timestamp'))\

                           .fetchone()[0]

        # get current time according to local server (i.e. Rattail), in UTC

        local_now = after

        drift += datetime.timedelta(seconds=1)

        # convert lastrun time to local timezone, for "other" queries

        # and finally, apply the drift

        return lastrun - drift

              ``uuid`` or ``username`` for one.

            """

            if self.rattail_config:

            else:

                from rattail.db import model

# Configure Continuum...this is trickier than I'd like.

configure_versioning(rattail_config, force=True)

orm.configure_mappers()

# add your model's MetaData object here

import sqlalchemy as sa

import rattail.db.types

from sqlalchemy.dialects import postgresql

def upgrade():

    for row in cursor.fetchall():

        if row['handheld_batch_uuid']:

            op.get_bind().execute(label_batch_handheld.insert().values({

                'batch_uuid': row['uuid'],

                'handheld_uuid': row['handheld_batch_uuid'],

                'ordinal': 1,

import sqlalchemy as sa

import rattail.db.types

from sqlalchemy.dialects import postgresql

def upgrade():

    for row in cursor.fetchall():

        if row['handheld_batch_uuid']:

            op.get_bind().execute(batch_inventory_handheld.insert().values({

                'batch_uuid': row['uuid'],

                'handheld_uuid': row['handheld_batch_uuid'],

                'ordinal': 1,

################################################################################

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

except ImportError:

    listen = None # old SQLAlchemy; will have to work around that, below

try:

    from rattail.db.continuum import versioning_manager

        recorder = recorder(config)

    elif recorder is None:

        if config:

            spec = config.get('rattail.db', 'changes.recorder', usedb=False)

            if spec:

        if not recorder:

            recorder = ChangeRecorder(config)

    else:

    session.rattail_change_recorder = recorder

    """

    Listener for session ``before_flush`` events.

    data propagation.

    """

    ignored_classes = (

    )

    # once upon a time we supposedly needed to specify `passive=True` when

    def __init__(self, config):

        self.config = config

        if self.config:

    def __call__(self, session, flush_context, instances):

        """

        """

        Return ``True`` if changes for the given object should be ignored.

        """

        # ignore certain classes per declaration

        if isinstance(obj, self.ignored_classes):

            return True

        """

        Record changes as appropriate, for the given 'deleted' object.

        """

        # TODO: should perhaps find a "cleaner" way to handle these..?

        # mark Person as dirty, when contact info is removed

        :returns: ``True`` if a change was recorded, or ``False`` if it was

           ignored.

        """

        # TODO: this check is now redundant due to `ignore_object()`

        # No need to record changes for changes.

        if isinstance(instance, (model.Change, model.DataSyncChange)):

        """

        Record a change, by creating a new change record in the session.

        """

        session.add(model.Change(**kwargs))

        if not quiet:

            log.debug("recorded {} for {} with key: {}".format(

        mapper = object_mapper(instance)

        if not mapper.columns['uuid'].foreign_keys:

            return

        for prop in mapper.iterate_properties:

                    instance.uuid = foreign_instance.uuid

                    return

        log.error("unexpected scenario; generated new UUID for instance: {0}".format(repr(instance)))

        continuum.make_versioned(**kwargs)

        # TODO: is this the best way/place to confirm versioning?

        try:

            configure_mappers()

            transaction_class = continuum.transaction_class(model.User)

            config.versioning_has_been_enabled = True

################################################################################

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

Core Data Stuff

"""

import sqlalchemy as sa

def uuid_column(*args, **kwargs):

    kwargs.setdefault('primary_key', True)

    kwargs.setdefault('nullable', False)

    return sa.Column(sa.String(length=32), *args, **kwargs)

################################################################################

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

from traceback import format_exception

from rattail.mail import Email

class ProblemReportEmail(Email):

    default_subject = "Email Update Request"

    def sample_data(self, request):

        customer = model.Customer(name="Fred Flintstone")

        return {

            'user': request.user,

    default_subject = "Phone Update Request"

    def sample_data(self, request):

        customer = model.Customer(name="Fred Flintstone")

        return {

            'user': request.user,

    handler_spec = None

    def get_handler(self, config):

    def get_default_subject(self, **data):

        host_title = data.get('host_title')

        return "Changes for {} -> {}".format(host_title, local_title)

    def sample_data(self, request):

        handler = self.get_handler(request.rattail_config)

        local_data = {

            'foo': 42,

            'bar': True,

    abstract = False

    def sample_data(self, request):

        person = model.Person(display_name="Fred Flintstone")

        user = model.User(username='fred', person=person)

        batch = model.InventoryBatch(id=42, created=self.app.localtime(),

    default_subject = "Upgrade failure for ${system_title}"

    def sample_data(self, request):

            description="upgrade to the latest!",

            notes="nothing special",

            executed_by="Fred Flintstone",

            exit_code=42,

        )

    default_subject = "Upgrade success for ${system_title}"

    def sample_data(self, request):

            description="upgrade to the latest!",

            notes="nothing special",

            executed_by="Fred Flintstone",

            exit_code=0,

        )

from rattail.db.util import make_topo_sortkey

    host_key = 'csv'

    generic_host_title = "CSV"

    def get_model(self):

        if self.config:

        from rattail.db import model

        return model

################################################################################

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

from rattail.importing.handlers import ToCSVHandler

    # subclass must define this

    FromParent = None