zenysis-py77 0.2.1__tar.gz

zenysis_py77-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Room 77, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zenysis_py77-0.2.1/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: zenysis-py77
+Version: 0.2.1
+Summary: Zenysis-maintained fork of the Room 77 Python Libraries
+Home-page: https://github.com/Zenysis/py77
+License: MIT
+Project-URL: Source, https://github.com/Zenysis/py77
+Project-URL: Upstream, https://github.com/room77/py77
+Provides: pylib
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides
+Dynamic: summary
+
+# Room 77 Python Libraries
+This is a collection of Python libraries used at Room 77, Inc.
+
+This is a fork maintained by Zenysis, since the original
+[room77/py77](https://github.com/room77/py77) is no longer maintained.
+
+## Installation
+Install from PyPI:
+
+    pip install zenysis-py77
+
+The package is still imported as `pylib` and installs the `zeus` command.
+
+Alternatively, clone the repo and include its path in your PYTHONPATH
+
+For example:
+
+  export PYTHONPATH=${PYTHONPATH}:/home/user/src/pylib
+
+
+Many of the pylib libraries can be used immediately without installing dependencies. The stable-requirements has not been cleaned and contains more dependencies than are necessary. The recommended approach is to not install the stable-requirements and attempt to use the library as is. Only install the requirements when they are needed.
+
+There is one additional dependency not in PyPi: GraphViz. To install the necessary Python bindings run
+
+    sudo apt-get install libgv-python
+
+Or the equivalent command for your operating system. Depending on your environment, it may be necessary to add the installed module to your Python path either by setting the PYTHONPATH environment variable or by creating symlinks to the installed module and shared library. On Debian, by default, `gv.py` and `_gv.so` are installed to `/usr/share/pyshared`.
+
+A `setup.py` file has been provided but is in experimental state. It is not recommended to install this way if you want to use `flash`
+
+## Components
+
+### Flash
+A declarative build system.
+
+### Zeus
+A task runner.
+
+### Master Packaging System
+A production deployment system.
+
+## License
+All code is distributed under the MIT license, unless otherwise noted. See LICENSE for details.

zenysis_py77-0.2.1/README.md

@@ -0,0 +1,43 @@
+# Room 77 Python Libraries
+This is a collection of Python libraries used at Room 77, Inc.
+
+This is a fork maintained by Zenysis, since the original
+[room77/py77](https://github.com/room77/py77) is no longer maintained.
+
+## Installation
+Install from PyPI:
+
+    pip install zenysis-py77
+
+The package is still imported as `pylib` and installs the `zeus` command.
+
+Alternatively, clone the repo and include its path in your PYTHONPATH
+
+For example:
+
+  export PYTHONPATH=${PYTHONPATH}:/home/user/src/pylib
+
+
+Many of the pylib libraries can be used immediately without installing dependencies. The stable-requirements has not been cleaned and contains more dependencies than are necessary. The recommended approach is to not install the stable-requirements and attempt to use the library as is. Only install the requirements when they are needed.
+
+There is one additional dependency not in PyPi: GraphViz. To install the necessary Python bindings run
+
+    sudo apt-get install libgv-python
+
+Or the equivalent command for your operating system. Depending on your environment, it may be necessary to add the installed module to your Python path either by setting the PYTHONPATH environment variable or by creating symlinks to the installed module and shared library. On Debian, by default, `gv.py` and `_gv.so` are installed to `/usr/share/pyshared`.
+
+A `setup.py` file has been provided but is in experimental state. It is not recommended to install this way if you want to use `flash`
+
+## Components
+
+### Flash
+A declarative build system.
+
+### Zeus
+A task runner.
+
+### Master Packaging System
+A production deployment system.
+
+## License
+All code is distributed under the MIT license, unless otherwise noted. See LICENSE for details.

zenysis_py77-0.2.1/pylib/base/environment.py

@@ -0,0 +1,17 @@
+"""
+module for managing machine environments
+"""
+
+__copyright__ = '2013, Room 77, Inc.'
+__author__ = 'Kyle Konrad'
+
+import os
+import subprocess
+
+__PRODUCTION_FILE = '/home/config/prod_machine'
+__STAGING_FILE = '/home/config/staging_machine'
+__TEST_FILE = '/localdisk/home/is_r77_test'
+
+IN_PRODUCTION = os.path.exists(__PRODUCTION_FILE)
+IN_STAGING = os.path.exists(__STAGING_FILE)
+IN_TEST = os.path.exists(__TEST_FILE)

zenysis_py77-0.2.1/pylib/base/exec_utils.py

@@ -0,0 +1,263 @@
+"""Utils file for the different build operations."""
+
+__author__ = 'pramodg@room77.com (Pramod Gupta)'
+__copyright__ = 'Copyright 2012 Room77, Inc.'
+
+from collections import deque
+from queue import Queue
+import multiprocessing
+import os
+import signal
+import subprocess
+import sys
+import shlex
+from threading import Thread, Timer
+
+from pylib.base.term_color import TermColor
+
+
+class KeyboardInterruptError(Exception):
+  """Exception to translate keyboard interrupt in child processes."""
+  def __init__(self, value="Keyboard Interrupt."):
+    self.value = value
+
+  def __str__(self):
+    return repr(self.value)
+
+
+class PicklableCallback():
+  """Class to use as a picklable callback(e.g. for pools)."""
+
+  def __call__(self, args):
+    """The default call method for the class. We want to explicitly handle
+    KeyboardInterrupt as otherwise this may lead to invalid child task.
+
+    Args:
+      args: tuple: List of args. We expect args to be as follows:
+          arg[0]: The class object.
+          arg[1]: Method to be called for the class object.
+          arg[2:]: All the arguments to be passed to the method.
+
+    Return:
+      Passes on the value from the called method.
+    """
+    try:
+      handler = getattr(args[0], args[1], None)
+      method_args = args[2:]
+      res = handler(*method_args)
+      sys.stdout.flush()
+      return res
+    except KeyboardInterrupt:
+      raise KeyboardInterruptError()
+
+
+class ExecUtils:
+  """Utility class."""
+
+  @staticmethod
+  def ExecuteParallel(args, pool_size=0, callback=PicklableCallback()):
+    """Executes a list of methods in parallel. Uses the PicklableCallback
+    as default callback to run individual handlers with the given set of args.
+
+    Args:
+      callback: callable method: A method that can be pickled and called.
+      args: list: List of args to pass to PicklableCallback which in turn calls
+          the callback handler.
+      pool_size: int: The size of the task pool.
+    Return:
+      list: Returns a list of results passed on by the callback handler.
+    """
+    if not args:
+      TermColor.Warning('Nothing to execute.')
+      return []
+
+    if not pool_size:
+      pool_size = max(multiprocessing.cpu_count(), 1)
+
+    # NOTE(stephen): Require use of `fork` for multiprocessing instead of `spawn` since
+    # there are issues with the reuse of some libraries (like Flags) when `spawn` is
+    # used.
+    pool = multiprocessing.get_context('fork').Pool(processes=pool_size)
+    try:
+      res = pool.map(callback, args)
+      pool.terminate()
+      sys.stdout.flush()
+      return res
+    except (KeyboardInterrupt, Exception) as e:
+      TermColor.Error('%s: %s' % (type(e), e))
+      # pool.close()
+      pool.terminate()
+      # Pass on the keyboard interrupt.
+      if type(e) == KeyboardInterrupt: raise e
+
+    sys.stdout.flush()
+    return []
+
+
+  @staticmethod
+  def ExecuteParallelGenerator(args, pool_size=0, callback=PicklableCallback()):
+    """Executes a list of methods in parallel. Uses the PicklableCallback
+    as default callback to run individual handlers with the given set of args.
+
+    Args:
+      callback: callable method: A method that can be pickled and called.
+      args: list: List of args to pass to PicklableCallback which in turn calls
+          the callback handler.
+      pool_size: int: The size of the task pool.
+    Return:
+      list: Returns a list of results passed on by the callback handler.
+    """
+    if not args:
+      TermColor.Warning('Nothing to execute.')
+      return []
+
+    if not pool_size:
+      pool_size = max(multiprocessing.cpu_count(), 1)
+
+    in_queue = Queue()
+    for job in args:
+        in_queue.put(job)
+    out_queue = Queue()
+    def worker(in_queue, out_queue):
+      while (job := in_queue.get()):
+        out_queue.put(callback(job))
+
+    for _ in range(pool_size):
+      Thread(target=worker, args=(in_queue, out_queue)).start()
+
+    try:
+      while True:
+        res = out_queue.get()
+        new_work = yield res
+        if new_work is None:
+          break
+        for job in new_work:
+          in_queue.put(job)
+        sys.stdout.flush()
+    except (KeyboardInterrupt, Exception) as e:
+      TermColor.Error('%s: %s' % (type(e), e))
+      # Pass on the keyboard interrupt.
+      if type(e) == KeyboardInterrupt: raise e
+    finally:
+      for _ in range(pool_size):
+        in_queue.put(None)
+      sys.stdout.flush()
+      yield None
+
+  @staticmethod
+  def ExecuteSequentiallyGenerator(args, pool_size=0, callback=PicklableCallback()):
+    """Executes a list of methods sequentially. Uses the PicklableCallback
+    as default callback to run individual handlers with the given set of args.
+
+    Args:
+      callback: callable method: A method that can be pickled and called.
+      args: list: List of args to pass to PicklableCallback which in turn calls
+          the callback handler.
+      pool_size: int: The size of the task pool.
+    Return:
+      list: Returns a list of results passed on by the callback handler.
+    """
+    if not args:
+      TermColor.Warning('Nothing to execute.')
+      return []
+
+    queue = deque(args)
+    try:
+      while queue:
+        job = queue.popleft()
+        new_jobs = yield callback(job)
+        queue.extend(new_jobs or ())
+      yield  # wait for the final sentinel
+    except (KeyboardInterrupt, Exception) as e:
+      TermColor.Error('%s: %s' % (type(e), e))
+      # Pass on the keyboard interrupt.
+      if type(e) == KeyboardInterrupt: raise e
+    finally:
+      sys.stdout.flush()
+
+  @staticmethod
+  def RunCmd(cmd, timeout_sec=sys.maxsize, piped_output=True, extra_env=None):
+    """Executes a command.
+    Args:
+      cmd: string: A string specifying the command to execute.
+      timeout: float: Timeout for the command in seconds.
+      piped_output: bool: Set to true if the output is to be dumped directly
+          to termimal.
+      extra_env: dict{string, string}: The extra environment variables to pass to the cmd.
+    """
+    TermColor.VInfo(2, 'Executing: %s' % cmd)
+
+    try:
+      if extra_env:
+        cmd_env = os.environ.copy()
+        cmd_env.update(extra_env)
+      else:
+        cmd_env = os.environ
+
+      timer = None
+      proc = None
+
+      if piped_output:
+        proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
+                                stderr=subprocess.STDOUT, env=cmd_env)
+      else:
+        proc = subprocess.Popen(cmd, shell=True, env=cmd_env)
+
+      # Start timeout.
+      timer = Timer(timeout_sec, ExecUtils.__ProcessTimedOut,
+                    [proc, cmd, timeout_sec])
+      timer.start()
+      (merged_out, unused) = proc.communicate()
+      timer.cancel()
+      retcode = proc.poll()
+      if not merged_out:
+        merged_out = ''
+
+      if retcode:
+        TermColor.Error('%s failed.\nErrorcode: %d' % (cmd, retcode))
+        TermColor.Info('%s Output: \n%s' % (cmd, merged_out))
+      else:
+        TermColor.VInfo(4, '%s Output: \n%s' % (cmd, merged_out))
+      return (retcode, merged_out)
+    except (KeyboardInterrupt, OSError) as e:
+      TermColor.Error('Command: %s failed. Error: %s' % (cmd, e))
+      if timer: timer.cancel()
+      if proc:
+        ExecUtils.__KillSubchildren(proc.pid)
+        proc.communicate()
+      # Pass on the keyboard interrupt.
+      if type(e) == KeyboardInterrupt: raise e
+    return (301, '')
+
+  @staticmethod
+  def __ProcessTimedOut(proc, cmd, timeout_sec):
+    """Handles timed out process. Kills the process and all its children.
+    Args:
+      cmd: string: The cmd that launched the proc.
+      proc: subprocess.Popen: The proc created for the command.
+      timeout_sec: int: The timeout for the process.
+    """
+    TermColor.Error('Command: %s Timed Out (%dsec)!' % (cmd, timeout_sec))
+    ExecUtils.__KillSubchildren(proc.pid)
+
+  @staticmethod
+  def __KillSubchildren(root_pid):
+    """Kills the process and all its subchildren specified by the pid.
+    Args:
+      root_pid: int: The pid of the process to be killed.
+    """
+    # Get all child processes.
+    p = subprocess.Popen('ps --no-headers -o pid --ppid %d' % root_pid,
+                         shell=True, stdout=subprocess.PIPE,
+                         stderr=subprocess.PIPE)
+    (stdout, stderr) = p.communicate()
+    pids = [int(p) for p in stdout.split()]
+
+    try:
+      os.kill(root_pid, signal.SIGKILL)
+    except OSError as e:
+      TermColor.Warning('Could not kill %d. Error %s' % (root_pid, e))
+
+    # Kill all subchildren recursively.
+    for pid in pids:
+      ExecUtils.__KillSubchildren(pid)

zenysis_py77-0.2.1/pylib/base/flags.py

@@ -0,0 +1,35 @@
+"""Flags."""
+
+__author__ = 'pramodg@room77.com (Pramod Gupta)'
+__copyright__ = 'Copyright 2012 Room77, Inc.'
+
+import argparse
+
+# HACK(stephen): Force add_subparsers to be backwards compatible since this
+# broke in Python 3.
+def build_parser():
+    parser = argparse.ArgumentParser(conflict_handler='resolve',
+      formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    # Workaround based on: https://stackoverflow.com/a/22994500
+    _add_subparsers = parser.add_subparsers
+    def add_subparsers(*args, **kwargs):
+        subparser = _add_subparsers(dest='', *args, **kwargs)
+        subparser.required = True
+        return subparser
+    parser.add_subparsers = add_subparsers
+    return parser
+
+class Flags:
+  """Class to manage command line flags."""
+  ARGS = argparse.Namespace()
+  PARSER = build_parser()
+  TESTING = False
+
+  @classmethod
+  def InitArgs(cls):
+    cls.ARGS = cls.PARSER.parse_args()
+
+# TODO(pramodg): See if we can replace testing above with an argument.
+# Flags.PARSER.add_argument('-t', '--testing', action='store_true', default=False,
+#                        help='Testing mode.')

zenysis_py77-0.2.1/pylib/base/term_color.py

@@ -0,0 +1,129 @@
+"""Terminal Logging implementation."""
+
+__author__ = 'pramodg@room77.com (Pramod Gupta)'
+__copyright__ = 'Copyright 2012 Room77, Inc.'
+
+import re
+import sys
+import traceback
+
+from pylib.base.flags import Flags
+
+Flags.PARSER.add_argument('-v', '--verbose', type=int, default=0,
+                          help='Verbosity level.')
+
+class TermColor:
+  """Class for manipulating terminal colors."""
+
+  CODE = {
+    'ENDC': 0,  # RESET COLOR
+    'BOLD': 1,
+    'UNDERLINE': 4,
+    'BLINK': 5,
+    'INVERT': 7,
+    'CONCEALD': 8,
+    'STRIKE': 9,
+    'GREY30': 90,
+    'GREY40': 2,
+    'GREY65': 37,
+    'GREY70': 97,
+    'GREY20_BG': 40,
+    'GREY33_BG': 100,
+    'GREY80_BG': 47,
+    'GREY93_BG': 107,
+    'DARK_RED': 31,
+    'RED': 91,
+    'RED_BG': 41,
+    'LIGHT_RED_BG': 101,
+    'DARK_YELLOW': 33,
+    'YELLOW': 93,
+    'YELLOW_BG': 43,
+    'LIGHT_YELLOW_BG': 103,
+    'DARK_BLUE': 34,
+    'BLUE': 94,
+    'BLUE_BG': 44,
+    'LIGHT_BLUE_BG': 104,
+    'DARK_MAGENTA': 35,
+    'PURPLE': 95,
+    'MAGENTA_BG': 45,
+    'LIGHT_PURPLE_BG': 105,
+    'DARK_CYAN': 36,
+    'AUQA': 96,
+    'CYAN_BG': 46,
+    'LIGHT_AUQA_BG': 106,
+    'DARK_GREEN': 32,
+    'GREEN': 92,
+    'GREEN_BG': 42,
+    'LIGHT_GREEN_BG': 102,
+    'BLACK': 30,
+  }
+
+  @staticmethod
+  def TermCode(num):
+      return '\033[%sm' % num
+
+  @staticmethod
+  def ColorStr(s, color):
+      return (TermColor.TermCode(TermColor.CODE[color]) + s +
+              TermColor.TermCode(TermColor.CODE['ENDC']))
+
+  @staticmethod
+  def PrintStr(s, color, print_trace=True):
+    if print_trace:
+     caller = traceback.extract_stack()[-3]
+     s = (caller[0] + ':' + str(caller[1]) + ': ' + s)
+
+    if sys.stdout.isatty():
+      s = TermColor.ColorStr(s, color)
+
+    print(s)
+
+  @staticmethod
+  def Fatal(s):
+    TermColor.PrintStr('FATAL: ' + s, 'RED_BG')
+    traceback.print_stack()
+    exit(1)
+
+  @staticmethod
+  def PrintException(s):
+    TermColor.PrintStr('Exception: ' + s, 'DARK_RED')
+    traceback.print_exc()
+
+  @staticmethod
+  def Error(s, print_stack=False):
+    TermColor.PrintStr('ERROR: ' + s, 'DARK_RED')
+    if print_stack: traceback.print_stack()
+
+  @staticmethod
+  def Warning(s):
+    TermColor.PrintStr('WARNING: ' + s, 'PURPLE')
+
+  @staticmethod
+  def Notice(s):
+    TermColor.PrintStr(s, 'ENDC')
+
+  @staticmethod
+  def Info(s):
+    TermColor.PrintStr(s, 'ENDC', False)
+
+  @staticmethod
+  def VInfo(level, s):
+    if level > Flags.ARGS.verbose: return
+    TermColor.Info(s)
+
+  @staticmethod
+  def VNotice(level, s):
+    if level > Flags.ARGS.verbose: return
+    TermColor.Notice(s)
+
+  @staticmethod
+  def Debug(s):
+    TermColor.PrintStr('DEBUG: ' + s, 'BLUE')
+
+  @staticmethod
+  def Success(s):
+    TermColor.PrintStr('SUCCESS: ' + s, 'GREEN', False)
+
+  @staticmethod
+  def Failure(s):
+    TermColor.PrintStr('FAILURE: ' + s, 'RED', False)

zenysis_py77-0.2.1/pylib/config/r77_init.py

@@ -0,0 +1,54 @@
+"""Common init to get the source root for files."""
+
+__author__ = 'pramodg@room77.com (Pramod Gupta)'
+__copyright__ = 'Copyright 2012 Room77, Inc.'
+
+import inspect
+import os
+import sys
+import traceback
+
+# This is needed to build binaries due to a bug in pyinstaller.
+# May be removed in future if the bug is fixed.
+import encodings
+
+# directory of the file this module is imported from
+_dir = os.path.dirname(os.path.realpath(os.path.abspath(
+      traceback.extract_stack()[-2][0])))
+
+##
+## NO NOT PRINT ANYTHING IN THIS FILE. Many files
+## include this file, and printing may mess up
+## file generation and other tasks that reply on output
+##
+
+def src_root():
+  """Returns the repository root."""
+  d = _dir
+  while (d and d != '/' and os.path.isdir(d) and not
+         os.path.exists(os.path.join(d, '.git'))):
+    d = os.path.dirname(d)
+  return d
+
+def pylib_parent_dir():
+  """Returns the directory containing pylib."""
+  d = _dir
+  while (d and d != '/' and os.path.isdir(d) and not
+         os.path.exists(os.path.join(d, 'pylib'))):
+    d = os.path.dirname(d)
+  if d is None or d == '/':
+    raise ValueError('r77_init must be imported from a file under pylib')
+  return d
+
+def e_dir():
+  """Returns the dir with generated code corresponding to this dir"""
+  return os.path.join(src_root(), 'e')
+
+PY_SRC = pylib_parent_dir()
+E = e_dir()
+# print 'SRC: %s' % SRC
+if PY_SRC not in sys.path:
+  sys.path.append(PY_SRC)
+if E not in sys.path:
+  sys.path.append(E)
+