vulcan-builder 0.2.4__py3-none-any.whl

vulcan/builder/__init__.py

@@ -0,0 +1,18 @@
+'''
+Lightweight Python Build Tool
+'''
+
+from vulcan.builder.common import nsh, dump, dumps, safe_cd
+from ._vb import task, async_task, main
+import sh
+import pkgutil
+
+__path__ = pkgutil.extend_path(__path__, __name__)
+
+__all__ = [
+    'task', 'async_task',
+    'main',
+    'nsh', 'sh',
+    'dump', 'dumps',
+    'safe_cd'
+  ]

vulcan/builder/_vb.py

@@ -0,0 +1,384 @@
+"""
+Lightweight Python Build Tool
+
+"""
+
+import inspect
+import argparse
+import logging
+import os
+from os import path
+import re
+import importlib.util
+import sys
+import time
+import concurrent.futures
+from vulcan.meta_builder import __version__
+from vulcan.builder.classes import CurrentThreadExecutor
+from vulcan.builder.classes import Task
+# from vulcan.builder.classes import LoggerWrapper
+
+_CREDIT_LINE = ("Powered by vb %s "
+                "- A Lightweight Python Build Tool." % __version__)
+_LOGGING_FORMAT = "[ %(name)s - %(message)s ]"
+_TASK_PATTERN = re.compile("^([^\\[]+)(\\[([^\\]]*)\\])?$")
+# "^([^\[]+)(\[([^\],=]*(,[^\],=]+)*(,[^\],=]+=[^\],=]+)*)\])?$"
+
+thread_pool_executor = concurrent.futures.ThreadPoolExecutor(max_workers=20)
+current_thread_executor = CurrentThreadExecutor()
+
+
+def load_source(name, filepath):
+    """
+    Load a build file as a module.
+
+    Replaces imp.load_source, gone in 3.12, including its handling of a name
+    already in sys.modules: the existing module is re-executed in place rather
+    than replaced, so references taken before the call stay valid.
+    """
+    # A build file is free to import the rest of its project by name, and it
+    # is not run from a directory Python would have put on the path itself.
+    directory = path.dirname(path.abspath(filepath))
+    if directory not in sys.path:
+        sys.path.insert(0, directory)
+
+    spec = importlib.util.spec_from_file_location(name, filepath)
+    module = sys.modules.get(name)
+    if module is None:
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def build(args):
+    """
+    Build the specified module with specified arguments.
+
+    @type module: module
+    @type args: list of arguments
+    """
+    # Build the command line.
+    parser = _create_parser()
+
+    # No args passed.
+    # if not args: #todo: execute default task.
+    #    parser.print_help()
+    #    print("\n\n"+_CREDIT_LINE)
+    #    exit
+    # Parse arguments.
+    args = parser.parse_args(args)
+
+    if args.version:
+        print('vb %s' % __version__)
+        sys.exit(0)
+
+    # load build file as a module
+    if not path.isfile(args.file):
+        print("Build file '%s' does not exist. "
+              "Please specify a build file\n" % args.file)
+        parser.print_help()
+        sys.exit(1)
+
+    module = load_source(path.splitext(
+        path.basename(args.file))[0], args.file)
+
+    # Run task and all its dependencies.
+    if args.list_tasks:
+        print_tasks(module, args.file)
+    elif not args.tasks:
+        if not _run_default_task(module):
+            parser.print_help()
+            print("\n")
+            print_tasks(module,  args.file)
+    else:
+        _run_from_task_names(module, args.tasks)
+
+
+def print_tasks(module, file):
+    # Get all tasks.
+    tasks = _get_tasks(module)
+
+    # Build task_list to describe the tasks.
+    task_list = "Tasks in build file %s:" % file
+    name_width = _get_max_name_length(module)+4
+    task_help_format = "\n  {0:<%s} {1: ^10} {2}" % name_width
+    default = _get_default_task(module)
+    for task in sorted(tasks, key=lambda task: task.name):
+        attributes = []
+        if task.ignored:
+            attributes.append('Ignored')
+        if task.async_task:
+            attributes.append('Async')
+        if default and task.name == default.name:
+            attributes.append('Default')
+
+        joined_attributes = ', '.join(attributes)
+        task_list += task_help_format.format(task.name,
+                                             ('[{}]'.format(joined_attributes))
+                                             if attributes else '',
+                                             task.doc)
+    print(task_list + "\n\n"+_CREDIT_LINE)
+
+
+def _get_default_task(module):
+    matching_tasks = [
+        task for name, task in inspect.getmembers(module, Task.is_task)
+        if name == "__DEFAULT__"]
+    if matching_tasks:
+        return matching_tasks[0]
+
+
+def _run_default_task(module):
+    default_task = _get_default_task(module)
+    if not default_task:
+        return False
+
+    completed_tasks = dict()
+    _run(module, _get_logger(module), default_task, completed_tasks)
+    for task in completed_tasks:
+        while completed_tasks.get(task).running():
+            time.sleep(0.5)
+
+    return True
+
+
+def _run_from_task_names(module, task_names):
+    """
+    @type module: module
+    @type task_name: string
+    @param task_name: Task name, exactly corresponds to function name.
+    """
+    # Create logger.
+    logger = _get_logger(module)
+    all_tasks = _get_tasks(module)
+    completed_tasks = dict()
+    for task_name in task_names:
+        task, args, kwargs = _get_task(module, task_name, all_tasks)
+        _run(module, logger, task, completed_tasks, True, args, kwargs)
+
+    for task in completed_tasks:
+        while completed_tasks.get(task).running():
+            time.sleep(0.5)
+
+
+def _get_task(module, name, tasks):
+    # Get all tasks.
+    match = _TASK_PATTERN.match(name)
+    if not match:
+        raise Exception("Invalid task argument %s" % name)
+    task_name, _, args_str = match.groups()
+
+    args, kwargs = _parse_args(args_str)
+    if hasattr(module, task_name):
+        return getattr(module, task_name), args, kwargs
+    matching_tasks = [
+        task for task in tasks if task.name.startswith(task_name)]
+
+    if not matching_tasks:
+        raise Exception("Invalid task '%s'. Task should be one of %s" %
+                        (name,
+                         ', '.join([task.name for task in tasks])))
+    if len(matching_tasks) == 1:
+        return matching_tasks[0], args, kwargs
+    raise Exception("Conflicting matches %s for task %s" % (
+        ', '.join([task.name for task in matching_tasks]), task_name
+    ))
+
+
+def _parse_args(args_str):
+    args = []
+    kwargs = {}
+    if not args_str:
+        return args, kwargs
+    arg_parts = args_str.split(",")
+
+    for i, part in enumerate(arg_parts):
+        if "=" in part:
+            key, value = [_str.strip() for _str in part.split("=")]
+            if key in kwargs:
+                raise Exception("duplicate keyword argument %s" % part)
+            kwargs[key] = value
+        else:
+            if len(kwargs) > 0:
+                raise Exception("Non keyword arg %s "
+                                "cannot follows a keyword arg %s"
+                                % (part, arg_parts[i - 1]))
+            args.append(part.strip())
+    return args, kwargs
+
+
+def _run(
+        module,
+        logger,
+        task,
+        completed_tasks,
+        from_command_line=False,
+        args=None,
+        kwargs=None):
+    """
+    @type module: module
+    @type logging: Logger
+    @type task: Task
+    @type completed_tasts: set Task
+    @rtype: set Task
+    @return: Updated set of completed tasks after satisfying all dependencies.
+    """
+    # Satsify dependencies recursively. Maintain set of completed tasks so each
+    # task is only performed once.
+
+    for dependency in task.dependencies:
+        _run(module, logger, dependency, completed_tasks)
+
+    for dependency in task.dependencies:
+        if not dependency.ignored:
+            while completed_tasks.get(dependency.name).running():
+                time.sleep(0.5)
+
+    # Perform current task, if need to.
+    if from_command_line or task.name not in completed_tasks:
+
+        if task.ignored:
+            logger.info("Ignoring task \"{}\"".format(task.name))
+        else:
+            try:
+                if task.async_task:
+                    executor = thread_pool_executor
+                else:
+                    executor = current_thread_executor
+
+                task.set_logger(logger)
+                running_task = executor.submit(
+                    task,
+                    *(args or []),
+                    **(kwargs or {})
+                )
+                completed_tasks[task.name] = running_task
+            except Exception:
+                logger.critical("Error starting task \"{name}\"".format(
+                    name=task.name))
+                logger.critical("Aborting build")
+                raise
+
+    return
+
+
+def _create_parser():
+    """
+    @rtype: argparse.ArgumentParser
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "tasks", help="perform specified task and all its dependencies",
+        metavar="task", nargs='*')
+
+    parser.add_argument(
+        '-l', '--list-tasks', help="List the tasks",
+        action='store_true')
+
+    parser.add_argument(
+        '-v', '--version',
+        help="Display the version information",
+        action='store_true')
+
+    parser.add_argument(
+        '-f', '--file',
+        help=("Build file to read the tasks from. "
+              "'build.py' is default value assumed "
+              "if this argument is unspecified"),
+        metavar="file", default="build.py")
+
+    return parser
+
+# Abbreviate for convenience.
+# task = _TaskDecorator
+
+
+def task(*dependencies, **options):
+    for i, dependency in enumerate(dependencies):
+        if not Task.is_task(dependency):
+            if inspect.isfunction(dependency):
+                # Throw error specific to the most likely form of misuse.
+                if i == 0:
+                    raise Exception("Replace use of @task with @task().")
+                else:
+                    raise Exception("%s is not a task. "
+                                    "Each dependency should be a task."
+                                    % dependency)
+            else:
+                raise Exception("%s is not a task." % dependency)
+
+    def decorator(fn):
+        return Task(fn, dependencies, options)
+    return decorator
+
+
+def async_task(*dependencies, **options):
+    for i, dependency in enumerate(dependencies):
+        if not Task.is_task(dependency):
+            if inspect.isfunction(dependency):
+                # Throw error specific to the most likely form of misuse.
+                if i == 0:
+                    raise Exception("Replace use of @task with @task().")
+                else:
+                    raise Exception("%s is not a task. "
+                                    "Each dependency should be a task."
+                                    % dependency)
+            else:
+                raise Exception("%s is not a task." % dependency)
+
+    def decorator(fn):
+        return Task(fn, dependencies, options, async_task=True)
+    return decorator
+
+
+def _get_tasks(module):
+    """
+    Returns all functions marked as tasks.
+
+    @type module: module
+    """
+    # Get all functions that are marked as task and pull out the task object
+    # from each (name,value) pair.
+    return set(
+        member[1] for member in inspect.getmembers(module, Task.is_task)
+    )
+
+
+def _get_max_name_length(module):
+    """
+    Returns the length of the longest task name.
+
+    @type module: module
+    """
+    return max([len(task.name) for task in _get_tasks(module)])
+
+
+def _get_logger(module):
+    """
+    @type module: module
+    @rtype: logging.Logger
+    """
+
+    # Create Logger
+    logger = logging.getLogger(os.path.basename(module.__file__))
+    logger.setLevel(logging.DEBUG)
+
+    # Create console handler and set level to debug
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.DEBUG)
+
+    # Create formatter
+    formatter = logging.Formatter(_LOGGING_FORMAT)
+
+    # Add formatter to ch
+    ch.setFormatter(formatter)
+
+    # Add ch to logger
+    logger.addHandler(ch)
+
+    return logger
+
+
+def main():
+    build(sys.argv[1:])

vulcan/builder/classes.py

@@ -0,0 +1,75 @@
+import inspect
+import time
+from datetime import datetime
+import logging
+from threading import Lock
+
+
+class Task(object):
+
+    def __init__(self, func, dependencies, options, **kwargs):
+        """
+        @type func: 0-ary function
+        @type dependencies: list of Task objects
+        """
+        self.func = func
+        self.name = func.__name__
+        self.doc = inspect.getdoc(func) or ''
+        self.dependencies = dependencies
+        self.ignored = bool(options.get('ignore', False))
+        self.async_task = kwargs.get('async_task', False)
+        self.logger = None
+
+    def __str__(self):
+        return self.name
+
+    def __call__(self, *args, **kwargs):
+        if self.logger:
+            if self.async_task:
+                self.logger.info("Starting async task \"{}\" in background".format(self.name))
+            else:
+                self.logger.info("Starting task \"{}\"".format(self.name))
+
+        t = datetime.now()
+
+        self.result = self.func.__call__(*args, **kwargs)
+
+        if self.logger:
+            self.logger.info("Completed task \"{task_name}\". Time: {run_time} sec".format(
+                    task_name=self.name, run_time=(datetime.now() - t).seconds
+                )
+            )
+
+        return self.result
+
+    def set_future(self, future):
+        self.future = future
+
+    def set_logger(self, logger):
+        self.logger = logger
+
+    @classmethod
+    def is_task(cls, obj):
+        """
+        Returns true is an object is a build task.
+        """
+        return isinstance(obj, cls)
+
+
+class CurrentThreadExecutor(object):
+
+    def __init__(self):
+        pass
+
+    def submit(self, task, *args, **kwargs):
+        task(*(args or []), **(kwargs or {}))
+        return PseudoFutureTask()
+
+
+class PseudoFutureTask(object):
+
+    def __init__(self):
+        pass
+
+    def running(self):
+        return False

vulcan/builder/common.py

@@ -0,0 +1,53 @@
+from datetime import datetime, date
+import json
+import sys
+import os
+import sh
+import contextlib
+
+
+def json_serial(obj):
+    """JSON serializer for objects not serializable by default json code"""
+
+    if isinstance(obj, (datetime, date)):
+        return obj.isoformat()
+    raise TypeError("Type %s not serializable" % type(obj))
+
+
+def dump(obj):
+    print('DUMP: {}'.format(json.dumps(obj, indent=1, default=json_serial)))
+
+
+def dumps(obj):
+    return json.dumps(obj, indent=1, default=json_serial)
+
+
+@contextlib.contextmanager
+def safe_cd(path):
+    starting_directory = os.getcwd()
+    try:
+        os.chdir(path)
+        yield
+    finally:
+        os.chdir(starting_directory)
+
+
+# Exr shell overriden methods
+
+def print_out(line):
+    sys.stdout.write(line)
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+
+
+def print_err(line):
+    sys.stderr.write(line)
+    sys.stderr.write("\n")
+    sys.stderr.flush()
+
+
+nsh = None
+if os.environ.get('TRAVIS', 'false') == 'true':
+    nsh = sh(_out=sys.stdout, _err_to_out=True)
+else:
+    nsh = sh(_out=sys.stdout, _err_to_out=True, _tty_in=True)

vulcan/meta_builder.py

@@ -0,0 +1,5 @@
+__version__ = "0.2.4"
+__license__ = "MIT License"
+__website__ = "https://code.exrny.com/opensource/vulcan-builder/"
+__download_url__ = ('https://github.com/exrny/vulcan-builder/archive/'
+                    '{}.tar.gz'.format(__version__))

vulcan_builder-0.2.4.dist-info/METADATA

@@ -0,0 +1,315 @@
+Metadata-Version: 2.4
+Name: vulcan-builder
+Version: 0.2.4
+Summary: Lightweight Python Build Tool.
+Home-page: https://code.exrny.com/opensource/vulcan-builder/
+Author: Peter Salnikov
+Author-email: opensource@exrny.com
+License: MIT License
+Keywords: devops,build tool
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+License-File: LICENSE.txt
+Requires-Dist: sh<2,>=1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+|Build Status|
+
+Vulcan Builder
+==============
+
+This project is a fork of Pynt by `Raghunandan
+Rao <https://github.com/rags/pynt>`__. We will contribute changes to the
+original rags/pynt repo.
+
+Vulcan Builder supports EXR’s applications via a lightweight, concise
+Python DevOps tool. We will develop our own improvements on the initial
+rags/pynt repo here and publish improvements to the original repo.
+
+This is an EXR Open Source project.
+
+A pynt of Python build.
+=======================
+
+Features
+--------
+
+-  Easy to learn.
+-  Build tasks are just python funtions.
+-  Manages dependencies between tasks.
+-  Automatically generates a command line interface.
+-  Rake style param passing to tasks
+-  Supports python 2.7 and python 3.x
+-  Async tasks
+
+Todo Features
+-------------
+
+-  Additional tasks timing reporting
+-  Debug mode
+
+Installation
+------------
+
+You can install vulcan-builder from the Python Package Index (PyPI) or
+from source.
+
+Using pip
+
+.. code:: bash
+
+   $ pip install vulcan-builder
+
+Using easy_install
+
+.. code:: bash
+
+   $ easy_install vulcan-builder
+
+Example
+-------
+
+The build script is written in pure Python and vulcan-builder takes care
+of managing any dependencies between tasks and generating a command line
+interface.
+
+Writing build tasks is really simple, all you need to know is the @task
+decorator. Tasks are just regular Python functions marked with the
+``@task()`` decorator. Dependencies are specified with ``@task()`` too.
+Tasks can be ignored with the ``@task(ignore=True)``. Disabling a task
+is an useful feature to have in situations where you have one task that
+a lot of other tasks depend on and you want to quickly remove it from
+the dependency chains of all the dependent tasks.
+
+**build.py**
+------------
+
+.. code:: python
+
+
+   #!/usr/bin/python
+
+   import sys
+   from vulcan.builder import task
+
+   @task()
+   def clean():
+       '''Clean build directory.'''
+       print 'Cleaning build directory...'
+
+   @task(clean)
+   def html(target='.'):
+       '''Generate HTML.'''
+       print 'Generating HTML in directory "%s"' %  target
+
+   @task(clean, ignore=True)
+   def images():
+       '''Prepare images.'''
+       print 'Preparing images...'
+
+   @task(html,images)
+   def start_server(server='localhost', port = '80'):
+       '''Start the server'''
+       print 'Starting server at %s:%s' % (server, port)
+
+   @task(start_server) #Depends on task with all optional params
+   def stop_server():
+       print 'Stopping server....'
+
+   @task()
+   def copy_file(src, dest):
+       print 'Copying from %s to %s' % (src, dest)
+
+   @task()
+   def echo(*args,**kwargs):
+       print args
+       print kwargs
+       
+   # Default task (if specified) is run when no task is specified in the command line
+   # make sure you define the variable __DEFAULT__ after the task is defined
+   # A good convention is to define it at the end of the module
+   # __DEFAULT__ is an optional member
+
+   __DEFAULT__=start_server
+
+**Running vulcan-builder tasks**
+--------------------------------
+
+The command line interface and help is automatically generated. Task
+descriptions are extracted from function docstrings.
+
+.. code:: bash
+
+   $ vb -h
+   usage: vb [-h] [-l] [-v] [-f file] [task [task ...]]
+
+   positional arguments:
+     task                  perform specified task and all its dependencies
+
+   optional arguments:
+     -h, --help            show this help message and exit
+     -l, --list-tasks      List the tasks
+     -v, --version         Display the version information
+     -f file, --file file  Build file to read the tasks from. Default is
+                           'build.py'
+
+.. code:: bash
+
+   $ vb -l
+   Tasks in build file ./build.py:
+     clean                       Clean build directory.
+     copy_file                   
+     echo                        
+     html                        Generate HTML.
+     images           [Ignored]  Prepare images.
+     start_server     [Default]  Start the server
+     stop_server                 
+
+   Powered by vulcan-builder - A Lightweight Python Build Tool.
+
+vulcan-builder takes care of dependencies between tasks. In the
+following case start_server depends on clean, html and image generation
+(image task is ignored).
+
+.. code:: bash
+
+   $ vb #Runs the default task start_server. It does exactly what "vb start_server" would do.
+   [ example.py - Starting task "clean" ]
+   Cleaning build directory...
+   [ example.py - Completed task "clean" ]
+   [ example.py - Starting task "html" ]
+   Generating HTML in directory "."
+   [ example.py - Completed task "html" ]
+   [ example.py - Ignoring task "images" ]
+   [ example.py - Starting task "start_server" ]
+   Starting server at localhost:80
+   [ example.py - Completed task "start_server" ]
+
+The first few characters of the task name is enough to execute the task,
+as long as the partial name is unambigious. You can specify multiple
+tasks to run in the commandline. Again the dependencies are taken taken
+care of.
+
+.. code:: bash
+
+   $ vb cle ht cl
+   [ example.py - Starting task "clean" ]
+   Cleaning build directory...
+   [ example.py - Completed task "clean" ]
+   [ example.py - Starting task "html" ]
+   Generating HTML in directory "."
+   [ example.py - Completed task "html" ]
+   [ example.py - Starting task "clean" ]
+   Cleaning build directory...
+   [ example.py - Completed task "clean" ]
+
+The ‘html’ task dependency ‘clean’ is run only once. But clean can be
+explicitly run again later.
+
+vb tasks can accept parameters from commandline.
+
+.. code:: bash
+
+   $ vb "copy_file[/path/to/foo, path_to_bar]"
+   [ example.py - Starting task "clean" ]
+   Cleaning build directory...
+   [ example.py - Completed task "clean" ]
+   [ example.py - Starting task "copy_file" ]
+   Copying from /path/to/foo to path_to_bar
+   [ example.py - Completed task "copy_file" ]
+
+vb can also accept keyword arguments.
+
+.. code:: bash
+
+   $ vb start[port=8888]
+   [ example.py - Starting task "clean" ]
+   Cleaning build directory...
+   [ example.py - Completed task "clean" ]
+   [ example.py - Starting task "html" ]
+   Generating HTML in directory "."
+   [ example.py - Completed task "html" ]
+   [ example.py - Ignoring task "images" ]
+   [ example.py - Starting task "start_server" ]
+   Starting server at localhost:8888
+   [ example.py - Completed task "start_server" ]
+       
+   $ vb echo[hello,world,foo=bar,blah=123]
+   [ example.py - Starting task "echo" ]
+   ('hello', 'world')
+   {'blah': '123', 'foo': 'bar'}
+   [ example.py - Completed task "echo" ]
+
+**Organizing build scripts**
+----------------------------
+
+You can break up your build files into modules and simple import them
+into your main build file.
+
+.. code:: python
+
+   from deploy_tasks import *
+   from test_tasks import functional_tests, report_coverage
+
+Contributors/Contributing
+-------------------------
+
+-  Raghunandan Rao - vulcan-builder is preceded by and forked from
+   `pynt <https://github.com/rags/pynt>`__, which was created by
+   `Raghunandan Rao <https://github.com/rags/pynt>`__.
+-  Calum J. Eadie - pynt is preceded by and forked from
+   `microbuild <https://github.com/CalumJEadie/microbuild>`__, which was
+   created by `Calum J. Eadie <https://github.com/CalumJEadie>`__.
+
+If you want to make changes the repo is at
+https://github.com/exrny/vulcan-builder. You will need
+`pytest <http://www.pytest.org>`__ to run the tests
+
+.. code:: bash
+
+   $ ./vb t
+
+It will be great if you can raise a `pull
+request <https://help.github.com/articles/using-pull-requests>`__ once
+you are done.
+
+If you find any bugs or need new features please raise a ticket in the
+`issues section <https://github.com/exrny/vulcan-builder/issues>`__ of
+the github repo.
+
+License
+-------
+
+vulcan-builder is licensed under a `MIT
+license <http://opensource.org/licenses/MIT>`__
+
+.. |Build Status| image:: https://travis-ci.org/exrny/vulcan-builder.png?branch=master
+   :target: https://travis-ci.org/exrny/vulcan-builder
+
+Changes
+=======
+
+0.2.4 - 12/09/2026
+------------------
+
+-  Load build files through importlib, as imp is gone in Python 3.12
+
+0.1.0 - 04/02/2018
+------------------
+
+-  Initial commit

vulcan_builder-0.2.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+vulcan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vulcan/meta_builder.py,sha256=vHDF6LBd-Xit7CjfBIQYhE1RcgGSAZInHrMnX_EBpDA,240
+vulcan/builder/__init__.py,sha256=BiEddRUWhDjgUcIE7vqLG8N1vQKN2kJELn6b8vLPx74,323
+vulcan/builder/_vb.py,sha256=uQTfvO20U2MHxEPAqKUC5-ixkEtXw4kK9hvXEfB5AUw,11528
+vulcan/builder/classes.py,sha256=hYrrWv3zWghcIOOZvO9oZUmgIzWXypd_J5bu4vzi2bw,1864
+vulcan/builder/common.py,sha256=lqzoZNsUMWfqNqj2Yba0jROjnb0T9lvCsyjYb4oTf8Y,1090
+vulcan_builder-0.2.4.dist-info/licenses/LICENSE.txt,sha256=mEH0HA2l6nLLaVo9M63FBbmRy4poRUBc9Xgu5aCt7Zo,1093
+vulcan_builder-0.2.4.dist-info/METADATA,sha256=xCQrdj5-Q8mWTxR79mK14rnfi3bPGDOfibFyV0KqZTA,9003
+vulcan_builder-0.2.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+vulcan_builder-0.2.4.dist-info/entry_points.txt,sha256=aJV6R0DCgfoy9lU0DCCPBD5OVOY3AHpwotmzIX0z994,43
+vulcan_builder-0.2.4.dist-info/top_level.txt,sha256=Wp8Ddga48cqQsqVTlPPjWVCX4e2R_XmTWdEbkQ4y4Hw,7
+vulcan_builder-0.2.4.dist-info/RECORD,,

vulcan_builder-0.2.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vulcan_builder-0.2.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vb = vulcan.builder:main

vulcan_builder-0.2.4.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (C) 2012 Raghunandan Rao
+Copyright (C) 2012 Calum J. Eadie
+
+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.

vulcan_builder-0.2.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+vulcan