Esempio n. 1
0
 def __call__(self, value, system):
     package, filename = resolve_asset_spec(self.info.name)
     template = os.path.join(package_path(self.info.package), filename)
     template_fh = open(template)
     template_stream = template_fh.read()
     template_fh.close()
     return pystache.render(template_stream, value)
Esempio n. 2
0
    def get_spec(self, name, package):
        if not package:
            # if there's no package, we can't do any conversion
            return name

        spec = name
        isabspath = os.path.isabs(name)
        colon_in_name = ':' in name
        isabsspec = colon_in_name and (not isabspath)
        isrelspec = (not isabsspec) and (not isabspath)

        # if it's already an absolute spec, we don't need to do anything,
        # but if it's a relative spec or an absolute path, we need to try
        # to convert it to an absolute spec

        if isrelspec:
            # convert relative asset spec to absolute asset spec
            pp = package_path(package)
            spec = os.path.join(pp, spec)
            spec = asset_spec_from_abspath(spec, package)

        elif isabspath:
            # convert absolute path to absolute asset spec
            spec = asset_spec_from_abspath(spec, package)

        return spec
Esempio n. 3
0
    def __call__(self, wrapped):
        settings = self.__dict__.copy()

        def callback(context, name, ob):
            context.config.add_view(view=ob, **settings)

        info = self.venusian.attach(wrapped, callback, category='bfg')

        if info.scope == 'class':
            # if the decorator was attached to a method in a class, or
            # otherwise executed at class scope, we need to set an
            # 'attr' into the settings if one isn't already in there
            if settings['attr'] is None:
                settings['attr'] = wrapped.__name__

        # try to convert the renderer provided into a fully qualified
        # resource specification
        abspath = settings.get('renderer')
        if abspath is not None and '.' in abspath:
            isabs = os.path.isabs(abspath)
            if not (':' in abspath and not isabs):
                # not already a resource spec
                if not isabs:
                    pp = package_path(info.module)
                    abspath = os.path.join(pp, abspath)
                resource = resource_spec_from_abspath(abspath, info.module)
                settings['renderer'] = resource

        return wrapped
Esempio n. 4
0
    def get_spec(self, name, package):
        if not package:
            # if there's no package, we can't do any conversion
            return name

        spec = name
        isabspath = os.path.isabs(name)
        colon_in_name = ":" in name
        isabsspec = colon_in_name and (not isabspath)
        isrelspec = (not isabsspec) and (not isabspath)

        # if it's already an absolute spec, we don't need to do anything,
        # but if it's a relative spec or an absolute path, we need to try
        # to convert it to an absolute spec

        if isrelspec:
            # convert relative asset spec to absolute asset spec
            pp = package_path(package)
            spec = os.path.join(pp, spec)
            spec = asset_spec_from_abspath(spec, package)

        elif isabspath:
            # convert absolute path to absolute asset spec
            spec = asset_spec_from_abspath(spec, package)

        return spec
Esempio n. 5
0
def config_defaults(configurator, config, files=['config.yml']):
    '''
        Reads and extends/creates configuration from yaml source.

        .. note::
            If exists, this method extends config with defaults, so it will not override existing values,
            merely add those, that were not defined already!

        :param pyramid.config.Configurator configurator: pyramid's app configurator
        :param string config: yaml file locations
        :param list files: list of files to include from location
    '''

    # getting spec path
    package_name, filename = resolve_asset_spec(config)
    if not package_name:
        path = filename
    else:
        __import__(package_name)
        package = sys.modules[package_name]
        path = os.path.join(package_path(package), filename)

    config = ConfigManager(files=[os.path.join(path, f) for f in files])

    # we could use this method both for creating and extending. Hence the checks to not override
    if not 'config' in configurator.registry:
        configurator.registry['config'] = config
    else:
        config.merge(configurator.registry['config'])
        configurator.registry['config'] = config
Esempio n. 6
0
    def add_translation_dirs(self, *specs):
        """ Add one or more :term:`translation directory` paths to the
        current configuration state.  The ``specs`` argument is a
        sequence that may contain absolute directory paths
        (e.g. ``/usr/share/locale``) or :term:`asset specification`
        names naming a directory path (e.g. ``some.package:locale``)
        or a combination of the two.

        Example:

        .. code-block:: python

           config.add_translation_dirs('/usr/share/locale',
                                       'some.package:locale')

        Later calls to ``add_translation_dir`` insert directories into the
        beginning of the list of translation directories created by earlier
        calls.  This means that the same translation found in a directory
        added later in the configuration process will be found before one
        added earlier in the configuration process.  However, if multiple
        specs are provided in a single call to ``add_translation_dirs``, the
        directories will be inserted into the beginning of the directory list
        in the order they're provided in the ``*specs`` list argument (items
        earlier in the list trump ones later in the list).
        """
        directories = []
        introspectables = []

        for spec in specs[::-1]: # reversed
            package_name, filename = self._split_spec(spec)
            if package_name is None: # absolute filename
                directory = filename
            else:
                __import__(package_name)
                package = sys.modules[package_name]
                directory = os.path.join(package_path(package), filename)

            if not os.path.isdir(os.path.realpath(directory)):
                raise ConfigurationError('"%s" is not a directory' %
                                         directory)
            intr = self.introspectable('translation directories', directory,
                                       spec, 'translation directory')
            intr['directory'] = directory
            intr['spec'] = spec
            introspectables.append(intr)
            directories.append(directory)

        def register():
            for directory in directories:

                tdirs = self.registry.queryUtility(ITranslationDirectories)
                if tdirs is None:
                    tdirs = []
                    self.registry.registerUtility(tdirs,
                                                  ITranslationDirectories)

                tdirs.insert(0, directory)

        self.action(None, register, introspectables=introspectables)
Esempio n. 7
0
def registerTemplateCustomizations(config, _dir, package):
    registry = config.registry
    if TEMPLATE_CUSTOMIZATIONS not in registry:
        registry[TEMPLATE_CUSTOMIZATIONS] = {}
    path = os.path.join(package_path(package), _dir)
    for fi in os.listdir(path):
        registry[TEMPLATE_CUSTOMIZATIONS][fi] = (package,
                                                 os.path.join(_dir, fi))
Esempio n. 8
0
def test_destination_package():
    """Testing translation package:path resolve."""
    request = Mock()
    request.registry = {'config': Mock()}
    mock_configuration = {'localize.translation.destination': 'tests:translations'}
    request.registry['config'].configure_mock(**mock_configuration)
    result = destination_path(request)
    assert result == os.path.join(package_path(sys.modules['tests']), 'translations')
Esempio n. 9
0
def registerTemplateCustomizations(config, _dir, package):
    registry = config.registry
    if TEMPLATE_CUSTOMIZATIONS not in registry:
        registry[TEMPLATE_CUSTOMIZATIONS] = {}
    path = os.path.join(package_path(package), _dir)
    for fi in os.listdir(path):
        registry[TEMPLATE_CUSTOMIZATIONS][fi] = (
            package, os.path.join(_dir, fi))
Esempio n. 10
0
    def add_translation_dirs(self, *specs):
        """ Add one or more :term:`translation directory` paths to the
        current configuration state.  The ``specs`` argument is a
        sequence that may contain absolute directory paths
        (e.g. ``/usr/share/locale``) or :term:`asset specification`
        names naming a directory path (e.g. ``some.package:locale``)
        or a combination of the two.

        Example:

        .. code-block:: python

           config.add_translation_dirs('/usr/share/locale',
                                       'some.package:locale')

        Later calls to ``add_translation_dir`` insert directories into the
        beginning of the list of translation directories created by earlier
        calls.  This means that the same translation found in a directory
        added later in the configuration process will be found before one
        added earlier in the configuration process.  However, if multiple
        specs are provided in a single call to ``add_translation_dirs``, the
        directories will be inserted into the beginning of the directory list
        in the order they're provided in the ``*specs`` list argument (items
        earlier in the list trump ones later in the list).
        """
        directories = []
        introspectables = []

        for spec in specs[::-1]:  # reversed
            package_name, filename = self._split_spec(spec)
            if package_name is None:  # absolute filename
                directory = filename
            else:
                __import__(package_name)
                package = sys.modules[package_name]
                directory = os.path.join(package_path(package), filename)

            if not os.path.isdir(os.path.realpath(directory)):
                raise ConfigurationError('"%s" is not a directory' % directory)
            intr = self.introspectable('translation directories', directory,
                                       spec, 'translation directory')
            intr['directory'] = directory
            intr['spec'] = spec
            introspectables.append(intr)
            directories.append(directory)

        def register():
            for directory in directories:

                tdirs = self.registry.queryUtility(ITranslationDirectories)
                if tdirs is None:
                    tdirs = []
                    self.registry.registerUtility(tdirs,
                                                  ITranslationDirectories)

                tdirs.insert(0, directory)

        self.action(None, register, introspectables=introspectables)
Esempio n. 11
0
 def test_package(self):
     '''testing translation package:path resolve'''
     request = Mock()
     mock_configuration = {
         'config.localize.translation.destination': 'tests:translations'}
     request.configure_mock(**mock_configuration)
     result = destination_path(request)
     self.assertEqual(result,
                      os.path.join(package_path(sys.modules['tests']),
                                   'translations'))
Esempio n. 12
0
    def __call__(self, value, system):
        """Render the template."""
        pkg, name = resolve_asset_spec(self.info.name)

        pkg_path = package_path(self.info.package)
        tpl_path = os.path.join(pkg_path, name)
        tpl_dir = os.path.split(tpl_path)[0]

        renderer = pystache.Renderer(search_dirs=[tpl_dir, pkg_path])
        return renderer.render_path(tpl_path, value)
Esempio n. 13
0
    def add_translation_dirs(self, *specs):
        """ Add one or more :term:`translation directory` paths to the
        current configuration state.  The ``specs`` argument is a
        sequence that may contain absolute directory paths
        (e.g. ``/usr/share/locale``) or :term:`asset specification`
        names naming a directory path (e.g. ``some.package:locale``)
        or a combination of the two.

        Example:

        .. code-block:: python

           config.add_translation_dirs('/usr/share/locale',
                                       'some.package:locale')

        Later calls to ``add_translation_dir`` insert directories into the
        beginning of the list of translation directories created by earlier
        calls.  This means that the same translation found in a directory
        added later in the configuration process will be found before one
        added earlier in the configuration process.  However, if multiple
        specs are provided in a single call to ``add_translation_dirs``, the
        directories will be inserted into the beginning of the directory list
        in the order they're provided in the ``*specs`` list argument (items
        earlier in the list trump ones later in the list).
        """
        for spec in specs[::-1]:  # reversed

            package_name, filename = self._split_spec(spec)
            if package_name is None:  # absolute filename
                directory = filename
            else:
                __import__(package_name)
                package = sys.modules[package_name]
                directory = os.path.join(package_path(package), filename)

            if not os.path.isdir(os.path.realpath(directory)):
                raise ConfigurationError('"%s" is not a directory' % directory)

            tdirs = self.registry.queryUtility(ITranslationDirectories)
            if tdirs is None:
                tdirs = []
                self.registry.registerUtility(tdirs, ITranslationDirectories)

            tdirs.insert(0, directory)
            # XXX no action?

        if specs:

            # We actually only need an IChameleonTranslate function
            # utility to be registered zero or one times.  We register the
            # same function once for each added translation directory,
            # which does too much work, but has the same effect.

            ctranslate = ChameleonTranslate(translator)
            self.registry.registerUtility(ctranslate, IChameleonTranslate)
Esempio n. 14
0
    def add_translation_dirs(self, *specs):
        """ Add one or more :term:`translation directory` paths to the
        current configuration state.  The ``specs`` argument is a
        sequence that may contain absolute directory paths
        (e.g. ``/usr/share/locale``) or :term:`asset specification`
        names naming a directory path (e.g. ``some.package:locale``)
        or a combination of the two.

        Example:

        .. code-block:: python

           config.add_translation_dirs('/usr/share/locale',
                                       'some.package:locale')

        Later calls to ``add_translation_dir`` insert directories into the
        beginning of the list of translation directories created by earlier
        calls.  This means that the same translation found in a directory
        added later in the configuration process will be found before one
        added earlier in the configuration process.  However, if multiple
        specs are provided in a single call to ``add_translation_dirs``, the
        directories will be inserted into the beginning of the directory list
        in the order they're provided in the ``*specs`` list argument (items
        earlier in the list trump ones later in the list).
        """
        for spec in specs[::-1]: # reversed

            package_name, filename = self._split_spec(spec)
            if package_name is None: # absolute filename
                directory = filename
            else:
                __import__(package_name)
                package = sys.modules[package_name]
                directory = os.path.join(package_path(package), filename)

            if not os.path.isdir(os.path.realpath(directory)):
                raise ConfigurationError('"%s" is not a directory' % directory)

            tdirs = self.registry.queryUtility(ITranslationDirectories)
            if tdirs is None:
                tdirs = []
                self.registry.registerUtility(tdirs, ITranslationDirectories)

            tdirs.insert(0, directory)
            # XXX no action?

        if specs:

            # We actually only need an IChameleonTranslate function
            # utility to be registered zero or one times.  We register the
            # same function once for each added translation directory,
            # which does too much work, but has the same effect.

            ctranslate = ChameleonTranslate(translator)
            self.registry.registerUtility(ctranslate, IChameleonTranslate)
Esempio n. 15
0
    def get_spec(self, name, package):
        spec = name
        isabs = os.path.isabs(name)

        if (not isabs) and (not ':' in name) and package:
            # relative asset spec
            if not isabs:
                pp = package_path(package)
                spec = os.path.join(pp, spec)
            spec = asset_spec_from_abspath(spec, package)
        return spec
Esempio n. 16
0
def asset_spec_from_abspath(abspath, package):
    """ Try to convert an absolute path to a resource in a package to
    a resource specification if possible; otherwise return the
    absolute path.  """
    if getattr(package, "__name__", None) == "__main__":
        return abspath
    pp = package_path(package) + os.path.sep
    if abspath.startswith(pp):
        relpath = abspath[len(pp) :]
        return "%s:%s" % (package_name(package), relpath.replace(os.path.sep, "/"))
    return abspath
Esempio n. 17
0
    def get_spec(self, name, package):
        spec = name
        isabs = os.path.isabs(name)

        if (not isabs) and (not ':' in name) and package:
            # relative resource spec
            if not isabs:
                pp = package_path(package)
                spec = os.path.join(pp, spec)
            spec = resource_spec_from_abspath(spec, package)
        return spec
Esempio n. 18
0
def test_destination_package():
    """Testing translation package:path resolve."""
    request = Mock()
    request.registry = {'config': Mock()}
    mock_configuration = {
        'localize.translation.destination': 'tests:translations'
    }
    request.registry['config'].configure_mock(**mock_configuration)
    result = destination_path(request)
    assert result == os.path.join(package_path(sys.modules['tests']),
                                  'translations')
Esempio n. 19
0
def test_destination_package():
    """Testing translation package:path resolve."""
    request = Mock()
    request.registry = {
        "localize":
        build_localize_config(
            {"localize.translation.destination": "tests:translations"})
    }
    result = destination_path(request)
    assert result == os.path.join(package_path(sys.modules["tests"]),
                                  "translations")
Esempio n. 20
0
def _asset_to_fixture(asset: str) -> Path:
    """Translate :term:`asset` to absolute fixture path."""
    package_name, file_name = resolve_asset_spec(asset)
    if package_name:
        package = __import__(package_name)
        path = Path(package_path(package), file_name)
    else:
        path = Path(file_name)
    if not path.is_dir():
        msg = 'This is not a directory {}'.format(asset)
        raise ConfigurationError(details=msg)
    return path
Esempio n. 21
0
def _asset_to_fixture(asset: str) -> Path:
    """Translate :term:`asset` to absolute fixture path."""
    package_name, file_name = resolve_asset_spec(asset)
    if package_name:
        package = __import__(package_name)
        path = Path(package_path(package), file_name)
    else:
        path = Path(file_name)
    if not path.is_dir():
        msg = 'This is not a directory {}'.format(asset)
        raise ConfigurationError(details=msg)
    return path
Esempio n. 22
0
def asset_spec_from_abspath(abspath, package):
    """ Try to convert an absolute path to a resource in a package to
    a resource specification if possible; otherwise return the
    absolute path.  """
    if getattr(package, '__name__', None) == '__main__':
        return abspath
    pp = package_path(package) + os.path.sep
    if abspath.startswith(pp):
        relpath = abspath[len(pp):]
        return '%s:%s' % (package_name(package),
                          relpath.replace(os.path.sep, '/'))
    return abspath
Esempio n. 23
0
def template_renderer_factory(info, impl, lock=registry_lock):
    spec = info.name
    reg = info.registry
    package = info.package

    isabs = os.path.isabs(spec)

    if (not isabs) and (not ':' in spec) and package:
        # relative resource spec
        if not isabs:
            pp = package_path(package)
            spec = os.path.join(pp, spec)
        spec = resource_spec_from_abspath(spec, package)
    
    if os.path.isabs(spec):
        # 'spec' is an absolute filename
        if not os.path.exists(spec):
            raise ValueError('Missing template file: %s' % spec)
        renderer = reg.queryUtility(ITemplateRenderer, name=spec)
        if renderer is None:
            renderer = impl(spec)
            # cache the template
            try:
                lock.acquire()
                reg.registerUtility(renderer, ITemplateRenderer, name=spec)
            finally:
                lock.release()
    else:
        # spec is a package:relpath resource spec
        renderer = reg.queryUtility(ITemplateRenderer, name=spec)
        if renderer is None:
            try:
                package_name, filename = spec.split(':', 1)
            except ValueError: # pragma: no cover
                # somehow we were passed a relative pathname; this
                # should die
                package_name = caller_package(4).__name__
                filename = spec
            abspath = pkg_resources.resource_filename(package_name, filename)
            if not pkg_resources.resource_exists(package_name, filename):
                raise ValueError(
                    'Missing template resource: %s (%s)' % (spec, abspath))
            renderer = impl(abspath)
            settings = info.settings
            if settings and not settings.get('reload_resources'):
                # cache the template
                try:
                    lock.acquire()
                    reg.registerUtility(renderer, ITemplateRenderer, name=spec)
                finally:
                    lock.release()
        
    return renderer
Esempio n. 24
0
    def _translation_template_path(self, spec):  # pylint:disable=no-self-use
        """
        Calculate path to translation template file.

        :param str spec: either full path, or package related path
        """
        # resolving possible asset spec to path (pyramid way):
        package_name, filename = resolve_asset_spec(spec)
        if package_name is None:  # absolute filename
            return os.path.abspath(filename)
        __import__(package_name)
        package = sys.modules[package_name]
        return os.path.abspath(os.path.join(package_path(package), filename))
Esempio n. 25
0
    def __call__(self, value, system):
        """
        Call to renderer.

        The renderer is cached for optimize access.
        """
        registry = system['request'].registry
        try:
            xsl = registry.getUtility(IRenderer, system['renderer_name'])
        except ComponentLookupError:
            xsl = XslRenderer(os.path.join(package_path(self._info.package),
                                           system['renderer_name']))
            registry.registerUtility(xsl, IRenderer, system['renderer_name'])
        return xsl(value, system)
Esempio n. 26
0
def create_static_url(obj, mixin_name, spec=None, wrapper_class=None):
    if spec is None:
        spec = obj.asset_spec
    if type(mixin_name) is tuple:
        spec, mixin_name = mixin_name
    asset_spec = "{spec}/{name}".format(spec=spec, name=mixin_name)
    try:
        return static_url_cache[(asset_spec, wrapper_class)]
    except KeyError:
        pass

    if spec[0:12] != 'solute.epfl:' and spec[0:12] != 'solute.epfl.':
        static_url_cache[(asset_spec,
                          wrapper_class)] = obj.request.static_path(asset_spec)
        if wrapper_class:
            static_url_cache[(asset_spec, wrapper_class)] = wrapper_class(
                static_url_cache[(asset_spec, wrapper_class)])
        return static_url_cache[(asset_spec, wrapper_class)]
    static_path = obj.request.static_path(asset_spec)

    static_mixin = 'static/'
    if spec == 'solute.epfl:static':
        static_mixin = ''

    output = {
        'base_path': path.package_path(solute.epfl),
        'relative_path': static_path[5:len(static_path) - len(mixin_name)],
        'mixin': static_mixin,
        'mixin_name': mixin_name
    }
    absolute_path = "{base_path}{relative_path}{mixin}{mixin_name}".format(
        **output)

    if exists(absolute_path):
        static_url_cache[(asset_spec,
                          wrapper_class)] = obj.request.static_path(asset_spec)
        if wrapper_class:
            static_url_cache[(asset_spec, wrapper_class)] = wrapper_class(
                static_url_cache[(asset_spec, wrapper_class)])
        return static_url_cache[(asset_spec, wrapper_class)]
    elif spec != 'solute.epfl:static':
        static_url_cache[(asset_spec, wrapper_class)] = create_static_url(
            obj, mixin_name, 'solute.epfl:static')
        if wrapper_class:
            static_url_cache[(asset_spec, wrapper_class)] = wrapper_class(
                static_url_cache[(asset_spec, wrapper_class)])
        return static_url_cache[(asset_spec, wrapper_class)]
    else:
        # return obj.request.static_path(asset_spec)
        raise Exception('Static dependency not found. %s' % asset_spec)
Esempio n. 27
0
    def _translation_template_path(self, spec):
        '''
            calculates path to translation template file

            :param str spec: either full path, or package related path
        '''
        # resolving possible asset spec to path (pyramid way):
        package_name, filename = resolve_asset_spec(spec)
        if package_name is None:  # absolute filename
            return os.path.abspath(filename)
        else:
            __import__(package_name)
            package = sys.modules[package_name]
            return os.path.abspath(os.path.join(package_path(package),
                                                filename))
Esempio n. 28
0
def prod_fullfile_app():
    """Configure the Pyramid application.
       We need to be sure that we get full path to pass always,
       no matter where this test is being run.
    """

    package_name, filename = resolve_asset_spec('tests:config')
    __import__(package_name)
    package = sys.modules[package_name]
    path = os.path.join(package_path(package), filename)
    # Configure redirect routes
    config = config_factory(**{'env': 'prod', 'yml.location': path})
    # Add routes for change_password, change_username,
    app = TestApp(config.make_wsgi_app())
    return App(app, config)
Esempio n. 29
0
def destination_path(request):
    '''
        Returns absolute path of the translation destination

        :param pyramid.request.Request request: a request object

        :returns: A combined translation destination path
        :rtype: str
    '''
    package_name, filename = resolve_asset_spec(request.config.localize.translation.destination)

    if package_name is None:  # absolute filename
        directory = filename
    else:
        __import__(package_name)
        package = sys.modules[package_name]
        directory = os.path.join(package_path(package), filename)
    return directory
Esempio n. 30
0
 def setUp(self):
     testing.setUp()
     self.tempdir = None
     import sys
     import os
     import tempfile
     from pyramid.path import package_path
     from pyramid.tests import fixtureapp as package
     import shutil
     tempdir = tempfile.mkdtemp()
     modname = 'myfixture%s' % self.i
     self.i += 1
     self.packagepath = os.path.join(tempdir, modname)
     fixturedir = package_path(package)
     shutil.copytree(fixturedir, self.packagepath)
     sys.path.insert(0, tempdir)
     self.module = __import__(modname)
     self.tempdir = tempdir
Esempio n. 31
0
def destination_path(request):
    """
    Return absolute path of the translation destination.

    :param pyramid.request.Request request: a request object

    :returns: A combined translation destination path
    :rtype: str
    """
    package_name, filename = resolve_asset_spec(
        request.registry['config'].localize.translation.destination)

    if package_name is None:  # absolute filename
        directory = filename
    else:
        __import__(package_name)
        package = sys.modules[package_name]
        directory = os.path.join(package_path(package), filename)
    return directory
Esempio n. 32
0
def _translate_config_path(location):
    """
    Translate location into fullpath according asset specification.

    Might be package:path for package related paths, or simply path

    :param str location: resource location
    :returns: fullpath

    :rtype: str
    """
    # getting spec path
    package_name, filename = resolve_asset_spec(location.strip())
    if not package_name:
        path = filename
    else:
        package = __import__(package_name)
        path = os.path.join(package_path(package), filename)

    return path
Esempio n. 33
0
def _translate_config_path(location):
    """
    Translate location into fullpath according asset specification.

    Might be package:path for package related paths, or simply path

    :param str location: resource location
    :returns: fullpath

    :rtype: str
    """
    # getting spec path
    package_name, filename = resolve_asset_spec(location.strip())
    if not package_name:
        path = filename
    else:
        package = __import__(package_name)
        path = os.path.join(package_path(package), filename)

    return path
Esempio n. 34
0
def quick_serve(sql_session_factory=None, port=8080):
    """Start a HTTP server for your REST service.

    This function provides quick way to run a webserver for your REST service.
    The webserver will listen on port 8080 on all IP addresses of the local
    machine.

    If you need to configure the underlying Pyramid system, or you want to use
    a different HTTP server you will need to create the WSGI application
    yourself. Instead of using `quick_serve` you will need to do something like
    this:

    .. code-block:: python
       :linenos:

       from pyramid.config import Configurator
       from wsgiref.simple_server import make_server

       config = Configurator()
       config.include('rest_toolkit')
       config.scan()
       app = config.make_wsgi_app()
       make_server('0.0.0.0', 8080, app).serve_forever()

    :param sql_session_factory: A factory function to return a SQLAlchemy
        session. This is generally a :py:class:`scoped_session
        <sqlalchemy:sqlalchemy.orm.session.scoped_session>` instance, and
        commonly called ``Session`` or ``DBSession``.
    :param int port: TCP port to use for HTTP server.
    """
    config = Configurator()
    config.include('rest_toolkit')
    if sql_session_factory is not None:
        config.include('rest_toolkit.ext.sql')
        config.set_sqlalchemy_session_factory(sql_session_factory)
    pkg = caller_package()
    config.add_static_view('static', package_path(pkg))
    config.scan(pkg)
    app = config.make_wsgi_app()
    server = make_server('0.0.0.0', port, app)
    server.serve_forever()
Esempio n. 35
0
def create_static_url(obj, mixin_name, spec=None, wrapper_class=None):
    if spec is None:
        spec = obj.asset_spec
    if type(mixin_name) is tuple:
        spec, mixin_name = mixin_name
    asset_spec = "{spec}/{name}".format(spec=spec, name=mixin_name)
    try:
        return static_url_cache[(asset_spec, wrapper_class)]
    except KeyError:
        pass

    if spec[0:12] != 'solute.epfl:' and spec[0:12] != 'solute.epfl.':
        static_url_cache[(asset_spec, wrapper_class)] = obj.request.static_path(asset_spec)
        if wrapper_class:
            static_url_cache[(asset_spec, wrapper_class)] = wrapper_class(static_url_cache[(asset_spec, wrapper_class)])
        return static_url_cache[(asset_spec, wrapper_class)]
    static_path = obj.request.static_path(asset_spec)

    static_mixin = 'static/'
    if spec == 'solute.epfl:static':
        static_mixin = ''

    output = {'base_path': path.package_path(solute.epfl),
              'relative_path': static_path[5:len(static_path) - len(mixin_name)],
              'mixin': static_mixin,
              'mixin_name': mixin_name}
    absolute_path = "{base_path}{relative_path}{mixin}{mixin_name}".format(**output)

    if exists(absolute_path):
        static_url_cache[(asset_spec, wrapper_class)] = obj.request.static_path(asset_spec)
        if wrapper_class:
            static_url_cache[(asset_spec, wrapper_class)] = wrapper_class(static_url_cache[(asset_spec, wrapper_class)])
        return static_url_cache[(asset_spec, wrapper_class)]
    elif spec != 'solute.epfl:static':
        static_url_cache[(asset_spec, wrapper_class)] = create_static_url(obj, mixin_name, 'solute.epfl:static')
        if wrapper_class:
            static_url_cache[(asset_spec, wrapper_class)] = wrapper_class(static_url_cache[(asset_spec, wrapper_class)])
        return static_url_cache[(asset_spec, wrapper_class)]
    else:
        # return obj.request.static_path(asset_spec)
        raise Exception('Static dependency not found. %s' % asset_spec)
Esempio n. 36
0
def quick_serve(sql_session_factory=None, port=8080):
    """Start a HTTP server for your REST service.

    This function provides quick way to run a webserver for your REST service.
    The webserver will listen on port 8080 on all IP addresses of the local
    machine.

    If you need to configure the underlying Pyramid system, or you want to use
    a different HTTP server you will need to create the WSGI application
    yourself. Instead of using `quick_serve` you will need to do something like
    this:

    .. code-block:: python
       :linenos:

       from pyramid.config import Configurator
       from wsgiref.simple_server import make_server

       config = Configurator()
       config.include('rest_toolkit')
       config.scan()
       app = config.make_wsgi_app()
       make_server('0.0.0.0', 8080, app).serve_forever()

    :param sql_session_factory: A factory function to return a SQLAlchemy
        session. This is generally a :py:class:`scoped_session
        <sqlalchemy:sqlalchemy.orm.session.scoped_session>` instance, and
        commonly called ``Session`` or ``DBSession``.
    :param int port: TCP port to use for HTTP server.
    """
    config = Configurator()
    config.include('rest_toolkit')
    if sql_session_factory is not None:
        config.include('rest_toolkit.ext.sql')
        config.set_sqlalchemy_session_factory(sql_session_factory)
    pkg = caller_package()
    config.add_static_view('static', package_path(pkg))
    config.scan(pkg)
    app = config.make_wsgi_app()
    server = make_server('0.0.0.0', port, app)
    server.serve_forever()
Esempio n. 37
0
 def __call__(self, value, system):
     """Render the template."""
     pkg, name = resolve_asset_spec(self.info.name)
     tpl = os.path.join(package_path(self.info.package), name)
     return pystache.render(open(tpl, 'r').read(), value)
 def _callFUT(self, package):
     from pyramid.path import package_path
     return package_path(package)
Esempio n. 39
0
"""Tests conftest file."""
import os
import sys

import pytest
from pyramid.asset import resolve_asset_spec
from pyramid.path import package_path
from pytest_pyramid import factories


package_name, filename = resolve_asset_spec('tests:config')
__import__(package_name)
package = sys.modules[package_name]
full_path = os.path.join(package_path(package), filename)


@pytest.fixture(scope='function',
                params=['tests:config', 'tests:config/config.yaml', full_path])
def base_config(request):
    """Basic config parametrized for different configuration location."""
    return factories.pyramid_config({
        'yaml.location': request.param,
        'pyramid.includes': ['tzf.pyramid_yml']
    })(request)


@pytest.fixture(scope='function',
                params=['tests:config', 'tests:config/config.yaml', full_path])
def prod_config(request):
    """Basic with env set parametrized for different configuration location."""
    return factories.pyramid_config({