pluginserver 0.5.2__py3-none-any.whl

plugincore/baseplugin.py

@@ -0,0 +1,54 @@
+from aiohttp import web
+
+class BasePlugin:
+    """
+    This is the base class for plugincore plugins. 
+    The constructor handles setting up the instance variables so the 
+    plugin can play nicely with the plugin manager.
+    """
+    def __init__(self, **kwargs):
+        self._auth_type = None
+        self._apikey = None
+        self.config = kwargs.get('config')
+        self._plugin_id = kwargs.get('route_path',self.__class__.__name__.lower())
+        auth = kwargs.get('auth_type').lower()
+        if auth:
+            if auth == 'global':
+                if 'auth' in self.config and 'apikey' in self.config.auth:
+                    self._apikey = self.config.auth.apikey
+                else:
+                    raise ValueError('Auth is global but no apikey in auth')
+                self._auth_type = 'global'
+            elif auth == 'plugin':
+                self._apikey = kwargs.get('apikey')
+                if not self._apikey:
+                    raise ValueError('Auth is plugin but no plugin apikey')
+                self._auth_type = 'plugin'
+        self.args = dict(kwargs)
+
+    def _check_auth(self,data):
+        #print(f"_check_auth: {self._auth_type} apikey {self._apikey}, args {data}")
+        if self._auth_type:
+            user_key = data.get('apikey')
+            #print(f"Checking {user_key}")
+            if not user_key:
+                #print("Returning false")
+                return False
+            keymatch = self._apikey == user_key
+            #print(f"Returning keymatch {keymatch}")
+            return keymatch
+        #print("returning default true")
+        return True
+
+    def _get_plugin_id(self):
+        return self._plugin_id
+    
+    async def handle_request(self, **data):
+        auth_check = self._check_auth(data)
+        if auth_check:
+            code, response = self.request_handler(**data)
+        else:
+            code, response = 403, {'error': 'unauthorized'}
+        if not isinstance(response,web.Response):
+            response_obj = web.json_response(response,status=code)
+        return response_obj   

plugincore/configfile.py

@@ -0,0 +1,192 @@
+import configparser
+import os
+import keyword
+import builtins
+import re
+from collections import UserDict
+
+def value_bool(value: any) -> bool:
+    if type(value) is str:
+        return value in ['true','enabled','on','1','enable']
+    if value:
+        return True
+    return False
+
+class Interpolator(configparser.ExtendedInterpolation):
+    """
+    This Interpolator class allows for variable interpolation in a few ways. Normally 
+    the values from the ini file are, programaticcallt, config[section][variable] or
+    config.section.variable and these are strings but sometimes we need better conversions
+    so this class converts:
+        int:42 to an int with the value of 42
+        float:3.14 to a float with the value of 3.14
+        bool: converts values of 'true','enabled','on','1','enable to True otherwise False
+        list:item1 item2 item3 ended with & or end of line. Each item is checked for type
+        conversion shown above. 
+        In addition ${ENV:var} will substitute ${ENV:var} with var from the user envionment.
+        ${section:var} will be replaced by the value of section.var in the file. 
+    """
+    _env_var_pattern = re.compile(r'\$\{ENV:([^}]+)\}')
+    _typed_value_pattern = re.compile(r'^(bool|int|float|list):(.*)', re.DOTALL)
+
+    def __init__(self):
+        super().__init__()
+        self._type_constructors = {
+            'bool': value_bool,
+            'int': int,
+            'float': float,
+            'list': self._convert_list,  # Add 'list' constructor here
+        }
+
+    def before_get(self, parser, section, option, value, defaults):
+        # Handle ${ENV:VAR}
+        value = self._env_var_pattern.sub(
+            lambda m: os.environ.get(m.group(1), ''), value
+        )
+
+        # Check for typed prefix
+        m = self._typed_value_pattern.match(value)
+        if m:
+            prefix, raw = m.group(1), m.group(2).lstrip()
+            converter = self._type_constructors.get(prefix)
+            if converter:
+                # Use the type constructor to convert the value
+                raw = converter(raw)
+                return raw
+            else:
+                return self._convert_list(raw)  # Handle as list if no matching type
+
+        return super().before_get(parser, section, option, value, defaults)
+
+    def _convert_list(self, raw):
+        # Process 'list:' prefix if it exists
+        if raw.startswith('list:'):
+            raw = raw[5:].lstrip()  # Remove 'list:' prefix
+
+        items = []
+        for token in raw.split():
+            # For each token, check for its type and apply conversion if necessary
+            m = self._typed_value_pattern.match(token)
+            if m:
+                prefix, item = m.group(1), m.group(2)
+                converter = self._type_constructors.get(prefix)
+                if converter:
+                    items.append(converter(item))  # Convert using the correct constructor
+                else:
+                    items.append(item)  # If no type prefix, add as-is
+            else:
+                items.append(token)  # If no match, add token as-is
+
+        return items
+    
+class Config(UserDict):
+    """ Parse and INI file for sections and keys, creating more Config objects for 
+       each section. 
+       usage: 
+       1 - read config file: 
+            Config(file=<pathname>, env_override=True|False)
+       2 - build object from dict in items: 
+            Config(items=<dict>, env_override=True|False)
+
+        returns a quasi dict-like object where object properties are also keys when referencing 
+        as a dict. 
+
+        Environment overrides are done when env_override=True and if there is a value 
+        of key (uppercase) in the environment. Key must exist in the ini_file. 
+
+        There are a few restrictions with the section and key names:
+            keys must start with alpha characters (A-Z, a-z)
+            keys must NOT be python keywords, builtins, or attributes or methods of the Config class
+            itself, or the word self as these will cause issues internally.
+
+        The configuration data is accessible with either dot or index notation. This class 
+        is based on UserDict so it will pretty much act like a dict.
+
+        See the Interpolator class above for information about how value strings are parsed.
+        """
+    def __init__(self, **kwargs):
+        self._foo = "foo"
+        super().__init__({})
+        section_name = kwargs.get('section_name')
+        env_prefix = kwargs.get('env_prefix')
+        filename = kwargs.get('file')
+        items = kwargs.get('items')
+        env_override = kwargs.get('env_override', False)
+
+        if not items and filename:
+            self.top_config = self;
+            config = config = configparser.ConfigParser(interpolation=Interpolator())
+            config.read(filename)
+            for section in config.sections():
+                if self._keyok(section,'main'):
+                    section_items = dict(config.items(section))
+                    conf = Config(top_config=self.top_config, items=section_items, env_override=env_override,env_prefix=env_prefix, section_name=section)
+                    setattr(self, section,conf)
+                    self.data[section] = conf
+        elif items:
+            self.top_config = kwargs.get('top_config',None)
+            for k, v in items.items():
+                if not section_name:
+                    sect = '-main-'
+                else:
+                    sect = section_name
+                    if not len(k):
+                        raise AttributeError(f"A key passed in {sect} was blank, this shouldn't happen")
+                    if not k[0].isalpha():
+                        raise AttributeError(f"Error in {sect}->{k}: configuration secions or keys must start with alpha characters")
+                if self._keyok(k,sect):
+                    if env_override:
+                        env_var = ""
+                        if env_prefix:
+                            env_var = f"{env_prefix.upper()}_"
+                        if section_name:
+                            env_var = env_var + f"{section_name.upper()}_"
+                        env_var = env_var + k.upper()
+                        if env_var in os.environ:
+                            v = os.environ[env_var]
+                    
+                    setattr(self, k, v)
+                    self.data[k] = v
+        else:
+            raise AttributeError('items or file must be specified')
+
+    @property
+    def _keys(self):
+        return self.data.keys()
+
+    def _keyok(self,k,sect):
+        _forbidden_keys = {
+            'python keyword': keyword.kwlist,
+            'python builtin': dir(builtins),
+            'class keyword': dir(self)+['self']
+        }
+        for ktype, klist in _forbidden_keys.items():
+            if k in klist:
+                raise AttributeError(f"Error in {sect}->{k}:, {k} is a {ktype} and may not be used")
+        return True
+
+    def __setitem__(self, key, item):
+        item = self._replace_env_vars(item)
+        print('setattr',self,key,item)
+        setattr(self,key,item)
+        return super().__setitem__(key, item)
+
+    def merge(self, other: "Config", overwrite: bool = True):
+        """
+        Merge another Config object into this one.
+
+        Args:
+            other (Config): Another config to merge from.
+            overwrite (bool): Whether to overwrite existing values.
+        """
+        for key in other._keys:
+            if key not in self._keys:
+                attr = getattr(other, key)
+                setattr(self, key, attr)
+                self.data[key] = attr
+            elif isinstance(getattr(self, key), Config) and isinstance(getattr(other, key), Config):
+                getattr(self, key).merge(getattr(other, key), overwrite=overwrite)
+            elif overwrite:
+                attr = getattr(other, key)
+                setattr(self, key, attr)
+                self.data[key] = attr

plugincore/cors.py

@@ -0,0 +1,92 @@
+from aiohttp import web
+import aiohttp_cors
+import aiohttp_cors
+from aiohttp import web
+import re
+from urllib.parse import urlparse
+
+class CORS:
+    def setup(self, app, globalCfg):
+        self.origins = []
+        self.acl = []
+        self.config = globalCfg
+        self.cors_enabled = False
+
+        # Check if CORS is enabled in the config
+        if 'cors' in self.config:
+            if 'enabled' in self.config.cors:
+                self.cors_enabled = self.config.cors.enabled  # Assuming this is a boolean
+            if self.cors_enabled:
+                # If enabled, fetch the allowed origins
+                if 'origin_url' in self.config.cors:
+                    self.origins = self.config.cors.origin_url  # List of allowed origins
+                else:
+                    # If origin_url is not set, disable CORS
+                    self.cors_enabled = False
+            if self.cors_enabled:
+                if 'acl' in self.config.cors:
+                    self.acl = self.config.cors.acl
+                    print(f"CORS setup, acl {self.acl}")
+
+        
+        # If CORS is enabled, set it up with aiohttp_cors
+        if self.cors_enabled:
+            print(f"CORS Setup - ORIGIN URLs: {self.origins}")
+            cors = aiohttp_cors.setup(app)
+            for route in list(app.router.routes()):
+                cors.add(route, {
+                    'origins': self.origins,
+                    'allow_credentials': True,
+                    'expose_headers': "*",
+                    'allow_headers': "*",
+                    'allow_methods': ["GET", "POST", "OPTIONS"]
+                })
+
+        return self
+
+    def _add_header(self, response, request):
+        """Add the CORS headers to the response."""
+        request_origin = request.headers.get('Origin')
+        if request_origin == 'null':
+            request_origin = None
+        if not request_origin:
+            return response
+        host_name = urlparse(request_origin).hostname
+
+        request_ok = True
+        if self.cors_enabled and request_origin:
+            if request_origin in self.origins:
+                response.headers['Access-Control-Allow-Origin'] = request_origin
+            else:
+                request_ok = False
+                if self.acl:
+                    for a in self.acl:
+                        pattern = r'^[a-zA-Z0-9.-]*\.' + re.escape(a) + r'$|^' + re.escape(a) + r'$'
+                        if re.match(pattern,urlparse(request_origin).hostname):
+                            request_ok = True
+                            break
+                if not request_ok:
+                    return web.HTTPForbidden(text="CORS origin not allowed")
+            
+            response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS'
+            response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
+            response.headers['Vary'] = 'Origin'
+        return response
+
+    def apply_headers(self, response, request):
+        """Apply CORS headers based on the response type."""
+        # Skip the CORS logic if CORS is disabled
+        if not self.cors_enabled:
+            return response  # No CORS logic applied
+
+        if isinstance(response, web.Response):
+            response = self._add_header(response, request)
+        elif isinstance(response, dict):
+            response = self._add_header(web.json_response(response), request)
+        elif isinstance(response, str):
+            response = self._add_header(web.Response(text=response, content_type='text/html'), request)
+        else:
+            response = self._add_header(web.json_response({'result': str(response)}), request)
+
+        response.headers['X-Content-Type-Options'] = 'nosniff'  # Security header
+        return response

plugincore/pluginmanager.py

@@ -0,0 +1,93 @@
+import sys
+import types
+import inspect
+import importlib.util
+import os
+import glob
+from typing import Dict, List, Union
+from plugincore import baseplugin
+from urllib.parse import parse_qs
+
+def parse_parameter_string(s):
+    return {key: value[0] for key, value in parse_qs(s).items()}
+
+class PluginManager:
+    def __init__(self, plugin_dir: str, **kwargs):
+        self.plugin_dir = plugin_dir
+        self.plugins: Dict[str, baseplugin.BasePlugin] = {}
+        self.modules: Dict[str, types.ModuleType] = {}
+        self.config = kwargs.get('config')
+        self.kwargs = dict(kwargs)
+
+    def _load_module(self, filepath: str) -> types.ModuleType:
+        mod_name = os.path.basename(filepath).replace(".py", "")
+        spec = importlib.util.spec_from_file_location(mod_name, filepath)
+        if spec is None or spec.loader is None:
+            raise ImportError(f"Cannot load module from {filepath}")
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        return mod
+
+    def _get_plugin_classes(self, mod: types.ModuleType) -> List[baseplugin.BasePlugin]:
+        classes = []
+        for name, cls in inspect.getmembers(mod, inspect.isclass):
+            if cls.__module__ == mod.__name__ and issubclass(cls, baseplugin.BasePlugin) and cls is not baseplugin.BasePlugin:
+                classes.append(cls)
+        return classes
+
+    def load_plugins(self):
+        plugin_files = glob.glob(os.path.join(self.plugin_dir, '*.py'))
+        print(f"Loading plugins from {self.plugin_dir}: {plugin_files}")
+        for path in plugin_files:
+            self.load_plugin(path)
+
+    def load_plugin(self, path: str):
+        plugin_module = os.path.splitext(os.path.basename(path))[0]  # strip .py
+        mod = self._load_module(path)
+        self.modules[plugin_module] = mod
+
+        for cls in self._get_plugin_classes(mod):
+            adict = {}
+            try:
+                adict = parse_parameter_string(self.config.plugin_parms[plugin_module])
+            except (AttributeError, KeyError):
+                pass
+            kwargs = self.kwargs.copy()
+            kwargs.update(adict)
+            kwargs['config'] = self.config
+            instance = cls(**kwargs)
+            print(f"Loaded plugin {cls.__name__}: {instance}")
+            self.plugins[instance._get_plugin_id()] = instance
+
+    def remove_plugin(self, plugin_id: str):
+        plugin = self.plugins.pop(plugin_id, None)
+        if not plugin:
+            print(f"No plugin with ID {plugin_id}")
+            return
+
+        # Try to remove the module
+        module_name = plugin.__class__.__module__
+        module_file = os.path.basename(module_name + ".py")
+        print(f"Removing plugin {plugin_id} from module {module_name}")
+
+        self.modules.pop(module_file, None)
+        sys.modules.pop(module_name, None)
+
+    def reload_plugin(self, plugin_id: str):
+        if plugin_id not in self.plugins:
+            print(f"No such plugin to reload: {plugin_id}")
+            return
+        plugin = self.plugins[plugin_id]
+        module_name = plugin.__class__.__module__
+        module_file = os.path.basename(module_name + ".py")
+        full_path = os.path.join(self.plugin_dir, module_file)
+
+        self.remove_plugin(plugin_id)
+        self.load_plugin(full_path)
+
+    def get_plugin(self, plugin_id: str):
+        return self.plugins.get(plugin_id)
+
+    def all_plugins(self):
+        return self.plugins
+

plugincore/pserv.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+import argparse
+import inspect
+import asyncio
+import ssl
+import os
+import sys
+import signal
+from aiohttp import web
+from plugincore import pluginmanager
+from plugincore import configfile
+import aiohttp_cors
+from plugincore.cors import CORS
+routes = web.RouteTableDef()
+manager = None  # PluginManager reference
+globalCfg = None
+import aiohttp_cors
+from aiohttp import web
+
+corsobj = CORS()
+def main():
+    global manager
+    global globalCfg
+
+    we_are = os.path.splitext(os.path.basename(sys.argv[0]))[0]
+
+    parser = argparse.ArgumentParser(
+        description="Plugin Server - create a RESTapi using simple plugins",
+        epilog="Nicole Stevens/2025"
+        )
+    parser.add_argument('-i','--ini-file',default=f"{we_are}.ini",type=str, metavar='ini-file',help='Use an alternate config file')
+    args = parser.parse_args()
+
+    signal.signal(signal.SIGHUP, reload)
+    print(f"{we_are}({os.getpid()}): Installed SIGHUP handler for reload.")
+
+    globalCfg = configfile.Config(file=args.ini_file)
+
+    ssl_ctx = None
+    ssl_cert, ssl_key = (None, None)
+    enabled = False
+
+    # SSL setup if enabled
+    try:
+        ssl_key = globalCfg.SSL.keyfile
+        ssl_cert = globalCfg.SSL.certfile
+        enabled = globalCfg.SSL.enabled
+    except AttributeError:
+        pass
+    if ssl_key and ssl_cert and enabled:
+        ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+        print("======== SSL Configuration ========")
+        print(f"SSL key {ssl_key}")
+        print(f"SSL certificate: {ssl_cert}")
+        print(f"SSL context {ssl_ctx}")
+        print("Loading SSL cert chain")
+        try:
+            ssl_ctx.load_cert_chain(ssl_cert, ssl_key, None)
+        except Exception as e:
+            print(f"Exception({type(e)}): Error loading ssl_cert_chain({ssl_cert},{ssl_key})")
+            for p in [ssl_cert, ssl_key]:
+                if not os.path.exists(p):
+                    print(f"Path: {p} not found.")
+            ssl_ctx = None
+        print("End of SSL configuration.")
+
+    if not 'paths' in globalCfg:
+        print(f"no paths in {globalCfg}")
+        sys.exit(1)
+    print("======== Loading plugin modules ========")
+    manager = pluginmanager.PluginManager(globalCfg.paths.plugins, config=globalCfg)
+    manager.load_plugins()
+
+    # Register plugin routes
+    for plugin_id, instance in manager.plugins.items():
+        register_plugin_route(plugin_id, instance, globalCfg)
+
+    # Setup event loop for file watcher
+
+    # Management endpoints
+    register_control_routes(globalCfg)
+
+    app = web.Application()
+    
+    # CORS setup
+    corsobj.setup(app,globalCfg)
+
+    app.add_routes(routes)
+    web.run_app(app, host=globalCfg.network.bindto, port=globalCfg.network.port, ssl_context=ssl_ctx)
+
+# --- Auth Helper ---
+def check_auth(data, config):
+    try:
+        expected = config.auth.apikey
+    except AttributeError:
+        expected = None
+    provided = data.get('apikey')
+    return expected and provided and expected == provided
+
+# --- Plugin Request Handler ---
+def register_plugin_route(plugin_id, instance, config):
+    print(f"Registering route: /{plugin_id} to {instance}")
+
+    @routes.route('*', f'/{plugin_id}')
+    @routes.route('*', f'/{plugin_id}/{{tail:.*}}')
+    async def handle(request, inst=instance, pid=plugin_id, cfg=config):
+        print(request.remote, '- request -', pid)
+        plugin = manager.get_plugin(pid)
+        data = {}
+        if request.method == 'POST' and request.can_read_body:
+            try:
+                data.update(await request.json())
+            except Exception:
+                pass
+        data.update(request.query)
+        data['request_headers'] = dict(request.headers)
+        # You can also capture `tail` if you want to use the subpath
+        try:
+            data['subpath'] = request.match_info['tail']
+        except KeyError:
+            data['subpath'] = None
+        response = await maybe_async(plugin.handle_request(**data))
+        response = corsobj.apply_headers(response, request)
+        return response
+
+# --- Control Routes ---
+def register_control_routes(config):
+    @routes.get('/plugins')
+    async def plugin_list(request):
+        data = dict(request.query)
+        if not check_auth(data, config):
+            return web.json_response({'error': 'unauthorized'}, status=403)
+        return corsobj.apply_headers(web.json_response({'loaded_plugins': list(manager.plugins.keys())}),request)
+
+    @routes.get('/reload/{plugin_id}')
+    async def reload_plugin(request):
+        data = dict(request.query)
+        if not check_auth(data, config):
+            return corsobj.apply_headers(web.json_response({'error': 'unauthorized'}, status=403),request)
+
+        pid = request.match_info['plugin_id']
+        if pid in manager.plugins:
+            success = manager.reload_plugin(pid)
+            return corsobj.apply_headers(web.json_response({'reloaded': pid, 'success': success}),request)
+        return corsobj.apply_headers(web.json_response({'error': f'Plugin "{pid}" not found'}, status=404),request)
+
+    @routes.get('/reload/all')
+    async def reload_all(request):
+        data = dict(request.query)
+        if not check_auth(data, config):
+            return corsobj.apply_headers(web.json_response({'error': 'unauthorized'}, status=403),request)
+        manager.load_plugins()
+        return corsobj.apply_headers(web.json_response({'status': 'All plugins reloaded', 'loaded_plugins': list(manager.plugins.keys())}),request)
+
+# --- Coroutine Await Helper ---
+async def maybe_async(value):
+    return await value if inspect.isawaitable(value) else value
+
+# ---- Reload handler ----
+def reload(signum, frame):
+    print("Received SIGHUP, restarting...")
+    os.execl(sys.executable, sys.executable, *sys.argv)
+
+if __name__ == "__main__":
+    main()

pluginserver-0.5.2.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: pluginserver
+Version: 0.5.2
+Summary: Plugin-driven API server
+Home-page: https://github.com/nicciniamh/pluginserver
+Author: Your Name
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+License-File: LICENSE.txt
+Requires-Dist: aiohttp
+Requires-Dist: aiohttp_cors
+Dynamic: author
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary

pluginserver-0.5.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+plugincore/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugincore/baseplugin.py,sha256=j9Kbp7jYv1VR6rwLVC3xsUnx1urGU4RLmY0tsTRw3A8,2080
+plugincore/configfile.py,sha256=d-B2Hlq_0K8-E9NcMVwx6V6NLNpBPmeAaXulhJs2NmU,7948
+plugincore/cors.py,sha256=eO9ZtBNIiEL8ZLa5cJhoI7vDZ-PlCYtBQf37-Qu9yxE,3770
+plugincore/pluginmanager.py,sha256=tl_5la_oavNo8xNKUr4t_z38hZJkBRvXASnKpeGH51E,3445
+plugincore/pserv.py,sha256=PQye9PRNZTfKRWw1EdGnKNYRM56ckWH5pYilKy8ikzw,5818
+pluginserver-0.5.2.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+pluginserver-0.5.2.dist-info/METADATA,sha256=4UKXFpq1bLOCwaMwvgyamKbPSwwWBJYc3kpaTh0zHxo,481
+pluginserver-0.5.2.dist-info/WHEEL,sha256=7ciDxtlje1X8OhobNuGgi1t-ACdFSelPnSmDPrtlobY,91
+pluginserver-0.5.2.dist-info/entry_points.txt,sha256=SMcJdZ-cComomjB0Bx5K8r845qBV6w4pxWnrDax7zlY,49
+pluginserver-0.5.2.dist-info/top_level.txt,sha256=P7DxYseqkcmCILUaPcViUwS-oUx_cLgBayrWS8gqaiA,11
+pluginserver-0.5.2.dist-info/RECORD,,

pluginserver-0.5.2.dist-info/WHEEL

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

pluginserver-0.5.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pserve = plugincore.pserv:main

pluginserver-0.5.2.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pluginserver-0.5.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+plugincore