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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

# import re

def upc_check_digit(data):

    """

        digit = int(reverse_data[i])

        if i % 2 == 0:

            digit *= 2

        sum_ += digit

    remainder = sum_ % 10

    if remainder == 0:

    .. _Price Check Digit algorithm: http://barcodes.gs1us.org/GS1%20US%20BarCodes%20and%20eCom%20-%20The%20Global%20Language%20of%20Business.htm#PCD

    """

    map1 = {0:0, 1:2, 2:4, 3:6, 4:8, 5:9, 6:1, 7:3, 8:5, 9:7}

    map2 = {0:0, 1:3, 2:6, 3:9, 4:2, 5:5, 6:8, 7:1, 8:4, 9:7}

    data = [int(x) for x in data]

    sum_ = map1[data[0]] + map1[data[1]] + map2[data[2]] + map3[data[3]]

def upce_to_upca(data, include_check_digit=False):

        upca = "0%05u00009" % int(upce[0:5])

    if include_check_digit:

    return upca

        # okay now print for real

        # TODO: this is compatible with legacy code but will re-read all needed

        # product data from master table instead of levaraging batch rows

            printer = profile.get_printer(self.config)

            printer.print_labels(profile.labels, progress=progress)

        Starts watcher and worker threads according to configuration.

        """

        watched = load_profiles(self.config)

            # Create a thread for watching the IMAP folder.

            watcher = IMAPWatcher(profile)

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

        if args.subcommand == 'register':

            try:

                palm.register_conduit()

        elif args.subcommand == 'unregister':

            try:

                palm.unregister_conduit()

class Upgrade(Subcommand):

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

import sys

import shlex

import datetime

import warnings

import logging

import logging.config

from rattail.util import load_entry_points, import_module_path

from rattail.exceptions import WindowsExtensionsNotInstalled, ConfigurationError

from rattail.files import temp_path

        return []

    # Per the shlex docs (https://docs.python.org/2/library/shlex.html):

    # "Prior to Python 2.7.3, this module did not support Unicode input."

        value = value.encode('utf-8')

    parser = shlex.shlex(value)

    parser.whitespace_split = True

    values = list(parser)

    for i, value in enumerate(values):

            values[i] = value[1:-1]

    return values

    def __init__(self, files=[], usedb=None, preferdb=None):

        self.files_requested = []

        self.files_read = []

        for path in files:

            self.read_file(path)

        self.usedb = usedb

        log.debug("will attempt to read config from file: {0}".format(path))

        self.files_requested.append(path)

            here=os.path.dirname(path),

        ))

        if not parser.read(path):

        try:

            logging.config.fileConfig(path, disable_existing_loggers=False)

            log.warning("tried to configure logging, but got NoSectionError: {0}".format(error))

        else:

            log.debug("configured logging")

        value = self.get(*args, **kwargs)

        if value is None:

            return None

            return parse_list(value)

        return value            # maybe a caller-provided default?

            files = files.split(os.pathsep)

        else:

            files = default_system_paths() + default_user_paths()

        files = [files]

    # If making config for a Windows service, we must read the default config

    # pass parameters to a Windows service.  This way we can effectively do

    # just that, via config.

    if winsvc is not None:

        parser.read(files)

        if parser.has_section('rattail.config'):

            key = 'winsvc.{0}'.format(winsvc)

    # Apply extra config for all available extensions.

    if extend:

        extensions = load_entry_points('rattail.config.extensions')

            log.debug("applying '{0}' config extension".format(extension.key))

            extension().configure(config)

            and record.levelno == logging.ERROR

            and record.msg == "Exception during reset or similar"

            and record.exc_info

            # Log this as a warning instead of error, to cut down on our noise.

            record.levelno = logging.WARNING

            # Product code is in first column...but so is a lot of other

            # garbage.  Use strict regex to find good rows.

            code = sheet.cell_value(r, 0)

                continue

            if not code_pattern.match(code):

                continue

        Constructor which assigns keyword arguments as attributes.

        """

            setattr(self, key, value)

    def __getitem__(self, key):

# This code was (mostly, with some tweaks) stolen from:

# http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/

import stat

from signal import SIGTERM 

class Daemon(object):

    """

    A generic daemon class.

            if pid > 0:

                # exit first parent

                sys.exit(0)

            sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))

            sys.exit(1)

            if pid > 0:

                # exit from second parent

                sys.exit(0)

            sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))

            sys.exit(1)

        # write pidfile

        atexit.register(self.delpid)

        with open(self.pidfile, 'w+') as f:

        os.chmod(self.pidfile, stat.S_IRUSR|stat.S_IWUSR)

    def delpid(self):

            while 1:

                os.kill(pid, SIGTERM)

                time.sleep(0.1)

            if err.find("No such process") > 0:

                if os.path.exists(self.pidfile):

                    os.remove(self.pidfile)

            else:

                sys.exit(1)

    def restart(self):

        """

        handler = load_object(self.handler_spec)

        importers = self.get_importers_from_handler(handler, default_only=True)

            if local_name in importers:

                importers[host_name] = importers[local_name]

        if self.skip_local_models:

        Process all changes, leveraging importer(s) as much as possible.

        """

        # Update all importers with current Rattail session.

            importer.session = session

        for change in changes:

        """

        Starts watcher and consumer threads according to configuration.

        """

            # Create watcher thread for the profile.

            name = '{0}-watcher'.format(key)

            target_session.set_continuum_user(self.runas_username)

        # update all importers with current sessions

            importer.host_session = session

            importer.session = target_session

            local_session.set_continuum_user(self.runas_username)

        # update all importers with current sessions

            importer.host_session = self.host_session

            importer.session = local_session

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

import logging

from sqlalchemy.orm import joinedload

from rattail.core import Object

    def get_key(self, instance, normalized):

        if callable(self.key):

            return self.key(instance, normalized)

            return getattr(instance, self.key)

        return tuple(getattr(instance, k) for k in self.key)

    def value(o, k):

        v = getattr(o, k)

            v = v.encode('utf_8')

        return v

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

from __future__ import unicode_literals, absolute_import

import sqlalchemy as sa

from sqlalchemy import orm

from sqlalchemy.ext.declarative import declared_attr

        """)

class PurchaseBatchCredit(PurchaseCreditBase, Base):

    """

    Represents a working copy of purchase credit tied to a batch row.

            List of :class:`PurchaseBatchCredit` instances for the row.

            """))

        if self.cases_shorted is not None and self.units_shorted is not None:

            qty = "{} cases, {} units".format(

                pretty_quantity(self.cases_shorted),

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

import datetime

import sqlalchemy as sa

from rattail.db.model import Base, uuid_column

class DataSyncChange(Base):

    """

    Represents a change obtained from a DataSync watcher thread, and destined

    configured as not "isolated".

    """)

        if self.payload_type and self.payload_key:

                self.payload_type,

                self.payload_key,

                " (deletion)" if self.deletion else "")

from rattail.db.model import Base, uuid_column

class TempmonClient(Base):

    """

    Represents a tempmon client.

    enabled = sa.Column(sa.Boolean(), nullable=False, default=False)

    online = sa.Column(sa.Boolean(), nullable=False, default=False)

        return '{} ({})'.format(self.config_key, self.hostname)

    def enabled_probes(self):

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

Database Synchronization

"""

import sys

import time

        self.remote_engines = remote_engines

    def loop(self):

        while True:

            try:

                self.synchronize()

                if error.connection_invalidated:

                    # Presumably a database server restart; give it a moment

                    # and try again.

            log.debug("Synchronizer.synchronize: found {0} change(s) to synchronize".format(len(local_changes)))

            remote_sessions = {}

                remote_sessions[key] = self.Session(bind=remote_engine)

            self.synchronize_changes(local_changes, local_session, remote_sessions)

                remote_session.commit()

                remote_session.close()

            local_session.commit()

                log.debug("Synchronizer.synchronize_changes: processing change: {0}".format(repr(change)))

                if change.deleted:

                        remote_instance = remote_session.query(klass).get(change.uuid)

                        if remote_instance:

                            self.delete_instance(remote_session, remote_instance)

                else: # new/dirty

                    local_instance = local_session.query(klass).get(change.uuid)

                    if local_instance:

                            self.merge_instance(remote_session, local_instance)

                            remote_session.flush()

        tables[table.name] = i

    log.debug("topo sortkeys for '{}' will be:\n{}".format(model.__name__, pprint.pformat(

    def sortkey(name):

        mapper = orm.class_mapper(getattr(model, name))

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

from __future__ import unicode_literals, absolute_import

class RattailError(Exception):

    """

    """

class SQLAlchemyNotInstalled(RattailError):

    """

    Error raised when an operation is requested which requires SQLAlchemy

    def __init__(self, error):

        self.error = error

        return ("Hm, looks like SQLAlchemy may not be installed?  "

                "(Perhaps you should do: 'pip install rattail[db]'?)  "

class WindowsExtensionsNotInstalled(RattailError):

    """

    Error raised when an operation is requested which requires the "Python for

    Windows Extensions" to be instealled, but it is not available.

    """

        return ("Cannot proceed because Python for Windows Extensions is not installed.  Please see "

                "https://rattailproject.org/moin/Installation/Windows/Python#Python_for_Windows_Extensions "

                "for more info.")

class MailTemplateNotFound(ConfigurationError):

    def __init__(self, key):

                "configured template folders.".format(self.key))

class SenderNotFound(ConfigurationError):

    def __init__(self, key):

        self.key = key

                "(or 'default.from') in the [rattail.mail] section.".format(self.key))

class RecipientsNotFound(ConfigurationError):

    def __init__(self, key):

        self.key = key

    def __str__(self):

        return ("No recipients found in config for '{0}' emails.  Please set '{0}.to' "

                "(or 'default.to') in the [rattail.mail] section.".format(self.key))

    """

class PathNotFound(FileOperationError):

    """

    Raised when "path not found" errors are encountered within the

    def __init__(self, original_error):

        self.original_error = original_error

            self.original_error.__class__.__name__,

            self.original_error)

    """

class PalmClassicDatabaseTypelibNotFound(PalmError):

        return ("The Python module for the Palm Classic Database type library "

                "could not be generated.  (Is the HotSync Manager software "

                "installed?)")

class PalmConduitManagerNotFound(PalmError):

        return ("The Palm Desktop Conduit Manager could not be instantiated.  "

                "(Is the HotSync Manager software installed?)")

class PalmConduitAlreadyRegistered(PalmError):

        return "The Rattail Palm conduit is already registered."

class PalmConduitNotRegistered(PalmError):

        return "The Rattail Palm conduit is not registered."

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

import re

import tempfile

from fabric.api import sudo, run, cd, local, env, settings, put as fab_put

from fabric.contrib.files import exists, append, upload_template as fab_upload_template, is_link

    """

    Recursively make one or more directories.

    """

        paths = [paths]

    sudo('mkdir --parents {0}'.format(' '.join(paths)))

    if owner != 'root:root':

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

Fabric Library for Python

"""

from contextlib import contextmanager

from fabric.api import sudo, run, prefix, cd, settings, env

from fabric.contrib.files import exists, append

    Context manager to prefix your command(s) with the ``cdvirtualenv`` command.

    """

    workon_home = workon_home or getattr(env, 'python_workon_home', '/srv/envs')

        subdirs = [subdirs]

    path = '{0}/{1}'.format(workon_home, name)

    if subdirs:

                | pyinotify.IN_MOVED_TO)

        monitored = load_profiles(self.config)

            # Create a file queue for the profile.

            profile.queue = Queue.Queue()

            return False

        # Create monitor and action threads for each profile.

            # Create a file queue for the profile.

            profile.queue = Queue.Queue()

        to ``'upc'``.

        """

        if calc_check_digit is True or calc_check_digit == 'upc':