Part of the Amoena Swimwear 2009 Cruise Series, the Amoena Nashville Jogger Swimsuit gives the illusion and style of a two-piece swimsuit with the security and comfort of a one-piece, all in a stylish dress. This one-piece swimsuit sports a black/white dots print. The Amoena Nashville Jogger Swimsuit offers premium support with a super support foam cup to go along with a full front/back lining.


text:
Rincklake (Schreibweise auch Rincklage) ist der Familienname von

 August Rincklake (1843–1915), deutscher Architekt des Historismus
 Wilhelm Rincklake (1851–1927) (weltlicher Name), kirchlich auch P. Ludger Rincklake OSB oder Ludgerus Rincklake, deutscher Architekt des Historismus, Bruder von August Rincklake
 Johann Christoph Rincklake (1764–1813), deutscher Maler der Romantik

redpajama_set_name: RedPajamaWikipedia


text:
import logging

from django.core.urlresolvers import reverse
from django import http

from mox import IsA

from horizon import exceptions
from horizon.workflows.views import WorkflowView

from openstack_dashboard import api
from openstack_dashboard.test import helpers as test
from openstack_dashboard.usage import quotas

from openstack_dashboard.dashboards.admin.projects.workflows \
    import CreateProject
from openstack_dashboard.dashboards.admin.projects.workflows \
    import UpdateProject

INDEX_URL = reverse('horizon:admin:projects:index')

@test.create_stubs({api.keystone: ('tenant_list',)})
class TenantsViewTests(test.BaseAdminViewTests):
    def test_index(self):
        api.keystone.tenant_list(IsA(http.HttpRequest),
                                 domain=None,
                                 paginate=True) \
            .AndReturn([self.tenants.list(), False])
        self.mox.ReplayAll()

        res = self.client.get(INDEX_URL)
        self.assertTemplateUsed(res, 'admin/projects/index.html')
        self.assertItemsEqual(res.context['table'].data, self.tenants.list())

    @test.create_stubs({api.keystone: ('tenant_list', )})
    def test_index_with_domain_context(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        domain_tenants = [tenant for tenant in self.tenants.list()
                          if tenant.domain_id == domain.id]
        api.keystone.tenant_list(IsA(http.HttpRequest),
                                 domain=domain.id) \
                    .AndReturn(domain_tenants)
        self.mox.ReplayAll()

        res = self.client.get(INDEX_URL)
        self.assertTemplateUsed(res, 'admin/projects/index.html')
        self.assertItemsEqual(res.context['table'].data, domain_tenants)
        self.assertContains(res, "test_domain:")

class CreateProjectWorkflowTests(test.BaseAdminViewTests):
    def _get_project_info(self, project):
        domain_id = self.request.session.get('domain_context', None)
        project_info = {"name": project.name,
                        "description": project.description,
                        "enabled": project.enabled,
                        "domain": domain_id}
        return project_info

    def _get_workflow_fields(self, project):
        project_info = {"name": project.name,
                        "description": project.description,
                        "enabled": project.enabled}
        return project_info

    def _get_quota_info(self, quota):
        cinder_quota = self.cinder_quotas.first()
        quota_data = {}
        for field in quotas.NOVA_QUOTA_FIELDS:
            quota_data[field] = int(quota.get(field).limit)
        for field in quotas.CINDER_QUOTA_FIELDS:
            quota_data[field] = int(cinder_quota.get(field).limit)
        return quota_data

    def _get_workflow_data(self, project, quota):
        project_info = self._get_workflow_fields(project)
        quota_data = self._get_quota_info(quota)
        project_info.update(quota_data)
        return project_info

    def _get_domain_id(self):
        return self.request.session.get('domain_context', None)

    def _get_all_users(self, domain_id):
        if not domain_id:
            users = self.users.list()
        else:
            users = [user for user in self.users.list()
                     if user.domain_id == domain_id]
        return users

    @test.create_stubs({api.keystone: ('get_default_role',
                                       'user_list',
                                       'role_list'),
                        quotas: ('get_default_quota_data',)})
    def test_add_project_get(self):
        quota = self.quotas.first()
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        roles = self.roles.list()

        quotas.get_default_quota_data(IsA(http.HttpRequest)).AndReturn(quota)

        # init
        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        self.mox.ReplayAll()

        url = reverse('horizon:admin:projects:create')
        res = self.client.get(url)

        self.assertTemplateUsed(res, WorkflowView.template_name)

        workflow = res.context['workflow']
        self.assertEqual(res.context['workflow'].name, CreateProject.name)

        step = workflow.get_step("createprojectinfoaction")
        self.assertEqual(step.action.initial['ram'], quota.get('ram').limit)
        self.assertEqual(step.action.initial['injected_files'],
                         quota.get('injected_files').limit)
        self.assertQuerysetEqual(workflow.steps,
                            ['<CreateProjectInfo: createprojectinfoaction>',
                             '<UpdateProjectMembers: update_members>',
                             '<UpdateProjectQuota: update_quotas>'])

    def test_add_project_get_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_add_project_get()

    @test.create_stubs({api.keystone: ('get_default_role',
                                       'add_tenant_user_role',
                                       'tenant_create',
                                       'user_list',
                                       'role_list'),
                        quotas: ('get_default_quota_data',),
                        api.cinder: ('tenant_quota_update',),
                        api.nova: ('tenant_quota_update',)})
    def test_add_project_post(self):
        project = self.tenants.first()
        quota = self.quotas.first()
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        roles = self.roles.list()

        # init
        quotas.get_default_quota_data(IsA(http.HttpRequest)).AndReturn(quota)

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # contribute
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # handle
        project_details = self._get_project_info(project)
        quota_data = self._get_quota_info(quota)

        api.keystone.tenant_create(IsA(http.HttpRequest), **project_details) \
                    .AndReturn(project)

        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        workflow_data = {}
        for role in roles:
            if "role_" + role.id in workflow_data:
                ulist = workflow_data["role_" + role.id]
                for user_id in ulist:
                    api.keystone.add_tenant_user_role(IsA(http.HttpRequest),
                                                      project=self.tenant.id,
                                                      user=user_id,
                                                      role=role.id)

        nova_updated_quota = dict([(key, quota_data[key]) for key in
                                   quotas.NOVA_QUOTA_FIELDS])
        api.nova.tenant_quota_update(IsA(http.HttpRequest),
                                     project.id,
                                     **nova_updated_quota)
        cinder_updated_quota = dict([(key, quota_data[key]) for key in
                                   quotas.CINDER_QUOTA_FIELDS])
        api.cinder.tenant_quota_update(IsA(http.HttpRequest),
                                       project.id,
                                       **cinder_updated_quota)

        self.mox.ReplayAll()

        workflow_data.update(self._get_workflow_data(project, quota))

        url = reverse('horizon:admin:projects:create')
        res = self.client.post(url, workflow_data)

        self.assertNoFormErrors(res)
        self.assertRedirectsNoFollow(res, INDEX_URL)

    def test_add_project_post_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_add_project_post()

    @test.create_stubs({api.keystone: ('user_list',
                                       'role_list',
                                       'get_default_role'),
                        quotas: ('get_default_quota_data',)})
    def test_add_project_quota_defaults_error(self):
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        roles = self.roles.list()

        # init
        quotas.get_default_quota_data(IsA(http.HttpRequest)) \
            .AndRaise(self.exceptions.nova)

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        self.mox.ReplayAll()

        url = reverse('horizon:admin:projects:create')
        res = self.client.get(url)

        self.assertTemplateUsed(res, WorkflowView.template_name)
        self.assertContains(res, "Unable to retrieve default quota values")

    def test_add_project_quota_defaults_error_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_add_project_quota_defaults_error()

    @test.create_stubs({api.keystone: ('tenant_create',
                                       'user_list',
                                       'role_list',
                                       'get_default_role'),
                        quotas: ('get_default_quota_data',)})
    def test_add_project_tenant_create_error(self):
        project = self.tenants.first()
        quota = self.quotas.first()
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        roles = self.roles.list()

        # init
        quotas.get_default_quota_data(IsA(http.HttpRequest)).AndReturn(quota)

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # contribute
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # handle
        project_details = self._get_project_info(project)

        api.keystone.tenant_create(IsA(http.HttpRequest), **project_details) \
            .AndRaise(self.exceptions.keystone)

        self.mox.ReplayAll()

        workflow_data = self._get_workflow_data(project, quota)

        url = reverse('horizon:admin:projects:create')
        res = self.client.post(url, workflow_data)

        self.assertNoFormErrors(res)
        self.assertRedirectsNoFollow(res, INDEX_URL)

    def test_add_project_tenant_create_error_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_add_project_tenant_create_error()

    @test.create_stubs({api.keystone: ('tenant_create',
                                       'user_list',
                                       'role_list',
                                       'get_default_role',
                                       'add_tenant_user_role'),
                        quotas: ('get_default_quota_data',),
                        api.nova: ('tenant_quota_update',)})
    def test_add_project_quota_update_error(self):
        project = self.tenants.first()
        quota = self.quotas.first()
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        roles = self.roles.list()

        # init
        quotas.get_default_quota_data(IsA(http.HttpRequest)).AndReturn(quota)

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # contribute
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # handle
        project_details = self._get_project_info(project)
        quota_data = self._get_quota_info(quota)

        api.keystone.tenant_create(IsA(http.HttpRequest), **project_details) \
            .AndReturn(project)

        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        workflow_data = {}
        for role in roles:
            if "role_" + role.id in workflow_data:
                ulist = workflow_data["role_" + role.id]
                for user_id in ulist:
                    api.keystone.add_tenant_user_role(IsA(http.HttpRequest),
                                                      project=self.tenant.id,
                                                      user=user_id,
                                                      role=role.id)

        nova_updated_quota = dict([(key, quota_data[key]) for key in
                                   quotas.NOVA_QUOTA_FIELDS])
        api.nova.tenant_quota_update(IsA(http.HttpRequest),
                                     project.id,
                                     **nova_updated_quota) \
           .AndRaise(self.exceptions.nova)

        self.mox.ReplayAll()

        workflow_data.update(self._get_workflow_data(project, quota))

        url = reverse('horizon:admin:projects:create')
        res = self.client.post(url, workflow_data)

        self.assertNoFormErrors(res)
        self.assertRedirectsNoFollow(res, INDEX_URL)

    def test_add_project_quota_update_error_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_add_project_quota_update_error()

    @test.create_stubs({api.keystone: ('tenant_create',
                                       'user_list',
                                       'role_list',
                                       'get_default_role',
                                       'add_tenant_user_role'),
                        quotas: ('get_default_quota_data',),
                        api.cinder: ('tenant_quota_update',),
                        api.nova: ('tenant_quota_update',)})
    def test_add_project_user_update_error(self):
        project = self.tenants.first()
        quota = self.quotas.first()
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        roles = self.roles.list()

        # init
        quotas.get_default_quota_data(IsA(http.HttpRequest)).AndReturn(quota)

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # contribute
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # handle
        project_details = self._get_project_info(project)
        quota_data = self._get_quota_info(quota)

        api.keystone.tenant_create(IsA(http.HttpRequest), **project_details) \
            .AndReturn(project)

        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        workflow_data = {}
        for role in roles:
            if "role_" + role.id in workflow_data:
                ulist = workflow_data["role_" + role.id]
                for user_id in ulist:
                    api.keystone.add_tenant_user_role(IsA(http.HttpRequest),
                                                      project=self.tenant.id,
                                                      user=user_id,
                                                      role=role.id) \
                       .AndRaise(self.exceptions.keystone)
                    break
            break

        nova_updated_quota = dict([(key, quota_data[key]) for key in
                                   quotas.NOVA_QUOTA_FIELDS])
        api.nova.tenant_quota_update(IsA(http.HttpRequest),
                                     project.id,
                                     **nova_updated_quota)

        cinder_updated_quota = dict([(key, quota_data[key]) for key in
                                    quotas.CINDER_QUOTA_FIELDS])
        api.cinder.tenant_quota_update(IsA(http.HttpRequest),
                                       project.id,
                                       **cinder_updated_quota)

        self.mox.ReplayAll()

        workflow_data.update(self._get_workflow_data(project, quota))

        url = reverse('horizon:admin:projects:create')
        res = self.client.post(url, workflow_data)

        self.assertNoFormErrors(res)
        self.assertRedirectsNoFollow(res, INDEX_URL)

    def test_add_project_user_update_error_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_add_project_user_update_error()

    @test.create_stubs({api.keystone: ('user_list',
                                       'role_list',
                                       'get_default_role'),
                        quotas: ('get_default_quota_data',)})
    def test_add_project_missing_field_error(self):
        project = self.tenants.first()
        quota = self.quotas.first()
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        roles = self.roles.list()

        # init
        quotas.get_default_quota_data(IsA(http.HttpRequest)).AndReturn(quota)

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # contribute
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        self.mox.ReplayAll()

        workflow_data = self._get_workflow_data(project, quota)
        workflow_data["name"] = ""

        url = reverse('horizon:admin:projects:create')
        res = self.client.post(url, workflow_data)

        self.assertContains(res, "field is required")

    def test_add_project_missing_field_error_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_add_project_missing_field_error()

class UpdateProjectWorkflowTests(test.BaseAdminViewTests):
    def _get_quota_info(self, quota):
        cinder_quota = self.cinder_quotas.first()
        quota_data = {}
        for field in quotas.NOVA_QUOTA_FIELDS:
            quota_data[field] = int(quota.get(field).limit)
        for field in quotas.CINDER_QUOTA_FIELDS:
            quota_data[field] = int(cinder_quota.get(field).limit)
        return quota_data

    def _get_domain_id(self):
        return self.request.session.get('domain_context', None)

    def _get_all_users(self, domain_id):
        if not domain_id:
            users = self.users.list()
        else:
            users = [user for user in self.users.list()
                     if user.domain_id == domain_id]
        return users

    def _get_proj_users(self, project_id):
        return [user for user in self.users.list()
                if user.project_id == project_id]

    @test.create_stubs({api.keystone: ('get_default_role',
                                       'roles_for_user',
                                       'tenant_get',
                                       'user_list',
                                       'role_list'),
                        quotas: ('get_tenant_quota_data',)})
    def test_update_project_get(self):
        project = self.tenants.first()
        quota = self.quotas.first()
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        roles = self.roles.list()

        api.keystone.tenant_get(IsA(http.HttpRequest),
                                self.tenant.id, admin=True) \
            .AndReturn(project)
        quotas.get_tenant_quota_data(IsA(http.HttpRequest),
                                     tenant_id=self.tenant.id) \
            .AndReturn(quota)

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        for user in users:
            api.keystone.roles_for_user(IsA(http.HttpRequest),
                                        user.id,
                                        self.tenant.id).AndReturn(roles)

        self.mox.ReplayAll()

        url = reverse('horizon:admin:projects:update',
                      args=[self.tenant.id])
        res = self.client.get(url)

        self.assertTemplateUsed(res, WorkflowView.template_name)

        workflow = res.context['workflow']
        self.assertEqual(res.context['workflow'].name, UpdateProject.name)

        step = workflow.get_step("update_info")
        self.assertEqual(step.action.initial['ram'], quota.get('ram').limit)
        self.assertEqual(step.action.initial['injected_files'],
                         quota.get('injected_files').limit)
        self.assertEqual(step.action.initial['name'], project.name)
        self.assertEqual(step.action.initial['description'],
                         project.description)
        self.assertQuerysetEqual(workflow.steps,
                            ['<UpdateProjectInfo: update_info>',
                             '<UpdateProjectMembers: update_members>',
                             '<UpdateProjectQuota: update_quotas>'])

    def test_update_project_get_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_update_project_get()

    @test.create_stubs({api.keystone: ('tenant_get',
                                       'tenant_update',
                                       'get_default_role',
                                       'roles_for_user',
                                       'remove_tenant_user_role',
                                       'add_tenant_user_role',
                                       'user_list',
                                       'role_list'),
                        api.nova: ('tenant_quota_update',),
                        api.cinder: ('tenant_quota_update',),
                        quotas: ('get_tenant_quota_data',)})
    def test_update_project_save(self):
        project = self.tenants.first()
        quota = self.quotas.first()
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        proj_users = self._get_proj_users(project.id)
        roles = self.roles.list()

        # get/init
        api.keystone.tenant_get(IsA(http.HttpRequest),
                                self.tenant.id, admin=True) \
            .AndReturn(project)
        quotas.get_tenant_quota_data(IsA(http.HttpRequest),
                                     tenant_id=self.tenant.id) \
            .AndReturn(quota)

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        workflow_data = {}
        for user in users:
            api.keystone.roles_for_user(IsA(http.HttpRequest),
                                        user.id,
                                        self.tenant.id).AndReturn(roles)

        workflow_data["role_1"] = ['3']  # admin role
        workflow_data["role_2"] = ['2']  # member role

        # update some fields
        project._info["name"] = "updated name"
        project._info["description"] = "updated description"
        quota.metadata_items = 444
        quota.volumes = 444

        updated_project = {"name": project._info["name"],
                           "description": project._info["description"],
                           "enabled": project.enabled}
        updated_quota = self._get_quota_info(quota)

        # contribute
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # handle
        api.keystone.tenant_update(IsA(http.HttpRequest),
                                   project.id,
                                   **updated_project) \
            .AndReturn(project)

        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
        api.keystone.user_list(IsA(http.HttpRequest),
                               project=self.tenant.id).AndReturn(proj_users)

        # admin user - try to remove all roles on current project, warning
        api.keystone.roles_for_user(IsA(http.HttpRequest), '1',
                                    self.tenant.id) \
                           .AndReturn(roles)

        # member user 1 - has role 1, will remove it
        api.keystone.roles_for_user(IsA(http.HttpRequest), '2',
                                    self.tenant.id) \
                           .AndReturn((roles[0],))
        # remove role 1
        api.keystone.remove_tenant_user_role(IsA(http.HttpRequest),
                                             project=self.tenant.id,
                                             user='2',
                                             role='1')
        # add role 2
        api.keystone.add_tenant_user_role(IsA(http.HttpRequest),
                                          project=self.tenant.id,
                                          user='2',
                                          role='2')

        # member user 3 - has role 2
        api.keystone.roles_for_user(IsA(http.HttpRequest), '3',
                                    self.tenant.id) \
                           .AndReturn((roles[1],))
        # remove role 2
        api.keystone.remove_tenant_user_role(IsA(http.HttpRequest),
                                             project=self.tenant.id,
                                             user='3',
                                             role='2')
        # add role 1
        api.keystone.add_tenant_user_role(IsA(http.HttpRequest),
                                          project=self.tenant.id,
                                          user='3',
                                          role='1')

        nova_updated_quota = dict([(key, updated_quota[key]) for key in
                                   quotas.NOVA_QUOTA_FIELDS])
        api.nova.tenant_quota_update(IsA(http.HttpRequest),
                                     project.id,
                                     **nova_updated_quota)

        cinder_updated_quota = dict([(key, updated_quota[key]) for key in
                                   quotas.CINDER_QUOTA_FIELDS])
        api.cinder.tenant_quota_update(IsA(http.HttpRequest),
                                       project.id,
                                       **cinder_updated_quota)
        self.mox.ReplayAll()

        # submit form data
        project_data = {"name": project._info["name"],
                        "id": project.id,
                        "description": project._info["description"],
                        "enabled": project.enabled}
        workflow_data.update(project_data)
        workflow_data.update(updated_quota)
        url = reverse('horizon:admin:projects:update',
                      args=[self.tenant.id])
        res = self.client.post(url, workflow_data)

        self.assertNoFormErrors(res)
        self.assertMessageCount(error=0, warning=1)
        self.assertRedirectsNoFollow(res, INDEX_URL)

    def test_update_project_save_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_update_project_save()

    @test.create_stubs({api.keystone: ('tenant_get',)})
    def test_update_project_get_error(self):

        api.keystone.tenant_get(IsA(http.HttpRequest), self.tenant.id,
                                admin=True) \
            .AndRaise(self.exceptions.nova)

        self.mox.ReplayAll()

        url = reverse('horizon:admin:projects:update',
                      args=[self.tenant.id])
        res = self.client.get(url)

        self.assertRedirectsNoFollow(res, INDEX_URL)

    @test.create_stubs({api.keystone: ('tenant_get',
                                       'tenant_update',
                                       'get_default_role',
                                       'roles_for_user',
                                       'remove_tenant_user',
                                       'add_tenant_user_role',
                                       'user_list',
                                       'role_list'),
                        quotas: ('get_tenant_quota_data',),
                        api.nova: ('tenant_quota_update',)})
    def test_update_project_tenant_update_error(self):
        project = self.tenants.first()
        quota = self.quotas.first()
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        roles = self.roles.list()

        # get/init
        api.keystone.tenant_get(IsA(http.HttpRequest), self.tenant.id,
                                admin=True) \
            .AndReturn(project)
        quotas.get_tenant_quota_data(IsA(http.HttpRequest),
                                     tenant_id=self.tenant.id) \
            .AndReturn(quota)

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        workflow_data = {}
        for user in users:
            api.keystone.roles_for_user(IsA(http.HttpRequest),
                                        user.id,
                                        self.tenant.id).AndReturn(roles)
            role_ids = [role.id for role in roles]
            if role_ids:
                workflow_data.setdefault("role_" + role_ids[0], []) \
                             .append(user.id)

        # update some fields
        project._info["name"] = "updated name"
        project._info["description"] = "updated description"
        quota.metadata_items = 444
        quota.volumes = 444

        updated_project = {"name": project._info["name"],
                           "description": project._info["description"],
                           "enabled": project.enabled}
        updated_quota = self._get_quota_info(quota)

        # contribute
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # handle
        api.keystone.tenant_update(IsA(http.HttpRequest),
                                   project.id,
                                   **updated_project) \
            .AndRaise(self.exceptions.keystone)

        self.mox.ReplayAll()

        # submit form data
        project_data = {"name": project._info["name"],
                        "id": project.id,
                        "description": project._info["description"],
                        "enabled": project.enabled}
        workflow_data.update(project_data)
        workflow_data.update(updated_quota)
        url = reverse('horizon:admin:projects:update',
                      args=[self.tenant.id])
        res = self.client.post(url, workflow_data)

        self.assertNoFormErrors(res)
        self.assertRedirectsNoFollow(res, INDEX_URL)

    def test_update_project_tenant_update_error_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_update_project_tenant_update_error()

    @test.create_stubs({api.keystone: ('tenant_get',
                                       'tenant_update',
                                       'get_default_role',
                                       'roles_for_user',
                                       'remove_tenant_user_role',
                                       'add_tenant_user_role',
                                       'user_list',
                                       'role_list'),
                        quotas: ('get_tenant_quota_data',),
                        api.nova: ('tenant_quota_update',)})
    def test_update_project_quota_update_error(self):
        project = self.tenants.first()
        quota = self.quotas.first()
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        proj_users = self._get_proj_users(project.id)
        roles = self.roles.list()

        # get/init
        api.keystone.tenant_get(IsA(http.HttpRequest), self.tenant.id,
                                admin=True) \
            .AndReturn(project)
        quotas.get_tenant_quota_data(IsA(http.HttpRequest),
                                     tenant_id=self.tenant.id) \
            .AndReturn(quota)

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        workflow_data = {}

        for user in users:
            api.keystone.roles_for_user(IsA(http.HttpRequest),
                                        user.id,
                                        self.tenant.id).AndReturn(roles)

        workflow_data["role_1"] = ['1', '3']  # admin role
        workflow_data["role_2"] = ['1', '2', '3']  # member role

        # update some fields
        project._info["name"] = "updated name"
        project._info["description"] = "updated description"
        quota[0].limit = 444
        quota[1].limit = -1

        updated_project = {"name": project._info["name"],
                           "description": project._info["description"],
                           "enabled": project.enabled}
        updated_quota = self._get_quota_info(quota)

        # contribute
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # handle
        # handle
        api.keystone.tenant_update(IsA(http.HttpRequest),
                                   project.id,
                                   **updated_project) \
            .AndReturn(project)

        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
        api.keystone.user_list(IsA(http.HttpRequest),
                               project=self.tenant.id).AndReturn(proj_users)

        # admin user - try to remove all roles on current project, warning
        api.keystone.roles_for_user(IsA(http.HttpRequest), '1',
                                    self.tenant.id) \
                           .AndReturn(roles)

        # member user 1 - has role 1, will remove it
        api.keystone.roles_for_user(IsA(http.HttpRequest), '2',
                                    self.tenant.id) \
                           .AndReturn((roles[1],))

        # member user 3 - has role 2
        api.keystone.roles_for_user(IsA(http.HttpRequest), '3',
                                    self.tenant.id) \
                           .AndReturn((roles[0],))
        # add role 2
        api.keystone.add_tenant_user_role(IsA(http.HttpRequest),
                                          project=self.tenant.id,
                                          user='3',
                                          role='2')

        nova_updated_quota = dict([(key, updated_quota[key]) for key in
                                   quotas.NOVA_QUOTA_FIELDS])
        api.nova.tenant_quota_update(IsA(http.HttpRequest),
                                     project.id,
                                     **nova_updated_quota) \
                            .AndRaise(self.exceptions.nova)

        self.mox.ReplayAll()

        # submit form data
        project_data = {"name": project._info["name"],
                         "id": project.id,
                         "description": project._info["description"],
                         "enabled": project.enabled}
        workflow_data.update(project_data)
        workflow_data.update(updated_quota)
        url = reverse('horizon:admin:projects:update',
                      args=[self.tenant.id])
        res = self.client.post(url, workflow_data)

        self.assertNoFormErrors(res)
        self.assertMessageCount(error=1, warning=0)
        self.assertRedirectsNoFollow(res, INDEX_URL)

    def test_update_project_quota_update_error_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_update_project_quota_update_error()

    @test.create_stubs({api.keystone: ('tenant_get',
                                       'tenant_update',
                                       'get_default_role',
                                       'roles_for_user',
                                       'remove_tenant_user_role',
                                       'add_tenant_user_role',
                                       'user_list',
                                       'role_list'),
                        quotas: ('get_tenant_quota_data',)})
    def test_update_project_member_update_error(self):
        project = self.tenants.first()
        quota = self.quotas.first()
        default_role = self.roles.first()
        domain_id = self._get_domain_id()
        users = self._get_all_users(domain_id)
        proj_users = self._get_proj_users(project.id)
        roles = self.roles.list()

        # get/init
        api.keystone.tenant_get(IsA(http.HttpRequest), self.tenant.id,
                                admin=True) \
            .AndReturn(project)
        quotas.get_tenant_quota_data(IsA(http.HttpRequest),
                                     tenant_id=self.tenant.id) \
            .AndReturn(quota)

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(default_role)
        api.keystone.user_list(IsA(http.HttpRequest), domain=domain_id) \
            .AndReturn(users)
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        workflow_data = {}
        for user in users:
            api.keystone.roles_for_user(IsA(http.HttpRequest),
                                        user.id,
                                        self.tenant.id).AndReturn(roles)
        workflow_data["role_1"] = ['1', '3']  # admin role
        workflow_data["role_2"] = ['1', '2', '3']  # member role

        # update some fields
        project._info["name"] = "updated name"
        project._info["description"] = "updated description"
        quota.metadata_items = 444
        quota.volumes = 444

        updated_project = {"name": project._info["name"],
                           "description": project._info["description"],
                           "enabled": project.enabled}
        updated_quota = self._get_quota_info(quota)

        # contribute
        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)

        # handle
        api.keystone.tenant_update(IsA(http.HttpRequest),
                                   project.id,
                                   **updated_project) \
            .AndReturn(project)

        api.keystone.role_list(IsA(http.HttpRequest)).AndReturn(roles)
        api.keystone.user_list(IsA(http.HttpRequest),
                               project=self.tenant.id).AndReturn(proj_users)

        # admin user - try to remove all roles on current project, warning
        api.keystone.roles_for_user(IsA(http.HttpRequest), '1',
                                    self.tenant.id).AndReturn(roles)

        # member user 1 - has role 1, will remove it
        api.keystone.roles_for_user(IsA(http.HttpRequest), '2',
                                    self.tenant.id).AndReturn((roles[1],))

        # member user 3 - has role 2
        api.keystone.roles_for_user(IsA(http.HttpRequest), '3',
                                    self.tenant.id).AndReturn((roles[0],))
        # add role 2
        api.keystone.add_tenant_user_role(IsA(http.HttpRequest),
                                          project=self.tenant.id,
                                          user='3',
                                          role='2')\
            .AndRaise(self.exceptions.keystone)

        self.mox.ReplayAll()

        # submit form data
        project_data = {"name": project._info["name"],
                        "id": project.id,
                        "description": project._info["description"],
                        "enabled": project.enabled}
        workflow_data.update(project_data)
        workflow_data.update(updated_quota)
        url = reverse('horizon:admin:projects:update',
                      args=[self.tenant.id])
        res = self.client.post(url, workflow_data)

        self.assertNoFormErrors(res)
        self.assertMessageCount(error=1, warning=0)
        self.assertRedirectsNoFollow(res, INDEX_URL)

    def test_update_project_member_update_error_domain(self):
        domain = self.domains.get(id="1")
        self.setSessionValues(domain_context=domain.id,
                              domain_context_name=domain.name)
        self.test_update_project_member_update_error()

    @test.create_stubs({api.keystone: ('get_default_role', 'tenant_get'),
                        quotas: ('get_tenant_quota_data',)})
    def test_update_project_when_default_role_does_not_exist(self):
        project = self.tenants.first()
        quota = self.quotas.first()

        api.keystone.get_default_role(IsA(http.HttpRequest)) \
            .AndReturn(None)  # Default role doesn't exist
        api.keystone.tenant_get(IsA(http.HttpRequest), self.tenant.id,
                                admin=True) \
            .AndReturn(project)
        quotas.get_tenant_quota_data(IsA(http.HttpRequest),
                                     tenant_id=self.tenant.id) \
            .AndReturn(quota)
        self.mox.ReplayAll()

        url = reverse('horizon:admin:projects:update',
                      args=[self.tenant.id])

        try:
            # Avoid the log message in the test output when the workflow's
            # step action cannot be instantiated
            logging.disable(logging.ERROR)
            with self.assertRaises(exceptions.NotFound):
                self.client.get(url)
        finally:
            logging.disable(logging.NOTSET)

redpajama_set_name: RedPajamaGithub


H&M shutters temporary office in Osaka.
OSAKA — Hennes & Mauritz Japan has shuttered its temporary offices here and plans to reopen its Tokyo headquarters Wednesday, a spokeswoman said Tuesday.
The fast-fashion retailer announced Thursday that it was setting up a temporary Osaka office and offered to relocate any of its 800 employees and their families to western Japan after a 9-magnitude quake and destructive tsunami struck the northeastern part of the country. But only a limited number of those people took up the offer, and most employees returned to Tokyo on Tuesday, the spokeswoman said.


text:
Kharoṣṭhī, Gāndhārī and Tibetan: Ancient Scripts
Dr Stefan Baums (LMU Munich)…..October 2013:…."This lecture compares the emergence of the Kharoṣṭhī scribal tradition around the fourth century BC and the Tibetan in the seventh century CE. Both scripts were adapted to previously unwritten languages, underwent a process of paleographic and orthographic standardization, and developed from instruments of empire and administration into the carriers of major Buddhist literary traditions. In addition to these parallels, the lecture suggests an unnoticed historical connection between the two scripts in the cultural meeting grounds of Central Asia"……http://www.soas.ac.uk/cia/tibetanstudies/events/11oct2013-kharoh-and-tibetan-two-scribal-traditions-and-a-hidden-connection.html
"Stefan Baums….I teach Sanskrit, Prakrit and Pali language and literature and South Asian Buddhism at the Institute for Indian and Tibetan Studies of the University of Munich and serve as lead researcher of the Buddhist Manuscripts from Gandhāra project at the Bavarian Academy of Sciences and Humanities. Before joining the University of Munich, I held research and teaching posts at the University of Copenhagen, the University of Washington, the University of California, Berkeley, and Leiden University, and was a Visiting Professor of South Asian and Buddhist Studies at the University of California, Berkeley. My research interests include Buddhist philology and epigraphy, the beginnings of written Buddhist literature, the interaction of written and oral modes of text transmission, the development of Buddhist hermeneutics, and the description of Gāndhārī language and literature. My current work focuses on the decipherment and edition of three Gāndhārī birch‐bark manuscripts containing commentaries on early Buddhist verses, and on a comprehensive study of the historical connections and exegetical principles of this group of verse commentaries and the related Gāndhārī Saṃgītisūtra commentary. I am the editor (with Andrew Glass) of the Dictionary of Gāndhārī." Dr. Stefan Baums
Institute for Indian and Tibetan Studies
University of Munich
baums@lmu.de
"The discovery of the earliest Buddhist manuscripts – written in Gāndhārī language and Kharoṣṭhī script and dating from the 1st c. BCE to the 4th c. CE – has revolutionized our understanding of this formative phase of Buddhism. On the way from India through Gandhāra to Central Asia and China, Buddhism turned into a world religion, and Gandhāra played a central role in the development of Buddhist scholasticism, Mahāyāna Buddhism and Buddhist art. The project 'Early Buddhist manuscripts from Gandhāra: religious literature at the interface of India, Central Asia and China' completes the edition of all known Gāndhārī manuscripts, contributes to the compilation of the Dictionary of Gāndhārī, and prepares a comprehensive Historical Grammar of Gāndhārī, Paleography of Kharoṣṭhī, and History of Gandhāran Literature and of Buddhism in Gandhāra. It collaborates with the Early Buddhist Manuscripts Project (University of Washington) in the study of the British Library collection of Gāndhārī scrolls and continues the work of the DFG project 'The Bajaur collection of Buddhist Kharoṣṭhī manuscripts' (Freie Universität Berlin, 2005–12). Funding is provided by the Union of the German Academies of Sciences and Humanities under the auspices of the Bavarian Academy of Sciences and Humanities."…..http://www.en.gandhara.indologie.uni-muenchen.de/index.html
"The oldest surviving Buddhist texts, preserved on long rolls of birch-tree bark, are written in Gandhari, an early regional Indic language that is long extinct. The scrolls originate from the region known in ancient times as Gandhara, which lies in what is now Northwestern Pakistan.".....http://archaeologynewsnetwork.blogspot.com
"The oldest dated birch bark manuscripts are numerous Gandhāran Buddhist texts from approximately the 1st century CE, believed to have originated in Afghanistan, likely by the Dharmaguptaka sect. Translations of the texts, mostly from Kharoṣṭhī script, have produced the earliest known versions of significant Buddhist scriptures, including: a Dhammapada; discourses of Buddha that include the Rhinoceros Horn Sutra; Avadanas; and Abhidharma texts. Sanskrit birch bark manuscripts, written with Brāhmī script, have been dated to the first few centuries CE. Several early Sanskrit writers, such as Kalidasa (c. 4th century CE), Sushruta (c. 3rd century CE), and Varahamihira (6th century CE) mention the use of birch bark for manuscripts. The bark of Betula utilis (Himalayan Birch) is still used today in India and Nepal for writing sacred mantras.
"The Gandhāran Buddhist texts are the oldest Buddhist manuscripts yet discovered, dating from about the 1st century CE.They are written in Gāndhārī, and are possibly the oldest extant Bactrian and Indian texts altogether. They were sold to European and Japanese institutions and individuals, and are currently being recovered and studied by several universities. The Gandhāran texts are in a considerably deteriorated form (their survival alone is extraordinary), but educated guesses about reconstruction have been possible in several cases using both modern preservation techniques and more traditional textual scholarship, comparing previously known Pāli and Buddhist Hybrid Sanskrit versions of texts. Other Gandhāran Buddhist texts—"several and perhaps many"—have been found over the last two centuries but lost or destroyed…..The texts are attributed to the Dharmaguptaka sect by Richard Salomon, the leading scholar in the field, and the British Library scrolls "represent a random but reasonably representative fraction of what was probably a much larger set of texts preserved in the library of a monastery of the Dharmaguptaka sect in Nagarāhāra."…..http://en.wikipedia.org/wiki/Gandhāran_Buddhist_texts
"Among the scrolls were found the earliest known versions of the Abidharma and Prajnaparamita texts, among other teachings. Scholars found that Mahayana and (then) Hinayana, rather than evolving sequentially, developed simultaneously, in an intertwined fashion. The conclusion specialists have drawn is that there is no single, original canon.... The Pali Canon is no longer the gold standard of what the Buddha taught, with other texts considered later additions."....http://newbuddhist.com/discussion/11592/significance-of-the-gandhari-scrolls-to-mahayana-theravada-split
"The Dharmaguptaka (Sanskrit: धर्मगुप्तक; Chinese: 法藏部; pinyin: Fǎzàng Bù) are one of the eighteen or twenty early Buddhist schools, depending on one's source. They are said to have originated from another sect, the Mahīśāsakas. The Dharmaguptakas had a prominent role in early Central Asian and Chinese Buddhism, and their monastic rules for bhikṣus and bhikṣuṇīs are still in effect in some East Asian countries to this day, including China, Vietnam, and Korea. They are one of three surviving Vinaya lineages, along with the Theravāda and the Mūlasarvāstivāda."….http://en.wikipedia.org/wiki/Dharmaguptaka
"Among the Dharmaguptaka Gandhāran Buddhist texts in the Schøyen Collection, is a fragment in the Kharoṣṭhī script referencing the Six Pāramitās, a central practice for bodhisattvas in Mahāyāna doctrine."…Patrick Cabouat and Alain Moreau (2004). "Eurasia Episode III - Gandhara, the Renaissance of Buddhism". Eurasia. Episode 3. 11:20 minutes in. France 5 / NHK / Point du Jour International.
"Pre-Islamic scripts in Afghanistan…..Afghanistan possesses a rich linguistic legacy of pre-Islamic scripts, which existed before being displaced by the Arabic alphabet, after the Islamic conquest of Afghanistan. Among these scripts are Sharada, Gandhari, Kharosthi, Bactrian and Brāhmī …..Abundant archeological evidence in the form of inscriptions, numismatics and manuscripts has provided traces of the precursors of the contemporary Languages of Afghanistan such as Pashto, Eastern Persian and other Dardic languages…"…..http://en.wikipedia.org/wiki/Pre-Islamic_scripts_in_Afghanistan
Bactrian Sanskrit…..Recent Archeological unearthings of Sanskrit inscriptions attest to the prevalence of the Sanskrit alphabet in Afghanistan. Some later Sanskrit inscriptions in late Brahmi of about around the fifth to eighth centuries have also been found in Afghanistan in recent decades. Worthy of note are the Dilberjin fresco inscriptions (Drevniaia Baktriia); the Gardez inscriptions on an image of Ganesa; and the Uma Maheshvara image inscriptions from Tapa Skandar. Several Buddhist inscriptions of this period with the Buddhist creed on votive clay tablets have also been discovered at Ghazni[….The Kushans employed Sanskrit abundantly for use in Buddhist literary texts, as is evident from epigraphic evidence. The presence of Buddhist literary texts in Sanskrit of the Kushan period goes hand in hand with the codification of the Sanskrit canon of the of the Sarvastivada school in Kashmir at the Buddhist council in the time of Kanishk…..Historians attest the largest population of the region including Bactria spoke vernacular dialects of Sanskrit."… The Silk Road in World History, Xinru Liu, Oxford University Press, p.46
Tibetan:…."The creation of the Tibetan alphabet is attributed to Thonmi Sambhota of the mid-7th century. Tradition holds that Thonmi Sambhota, a minister of Songtsen Gampo (569-649), was sent to India to study the art of writing, and upon his return introduced the alphabet. The form of the letters is based on an Indic alphabet of that period….Which specific Indic script inspired the Tibetan alphabet remains controversial. Recent study suggests Tibetan script was based on an adaption from Khotan of the Indian Brahmi and Gupta scripts taught to Thonmi Sambhota in Kashmir (Berzin, Alexander. A Survey of Tibetan History - Reading Notes Taken by Alexander Berzin from Tsepon, W. D. Shakabpa, Tibet: A Political History. New Haven, Yale University Press, 1967: http://www.berzinarchives.com/web/en/archives/e-books/unpublished_manuscripts/survey_tibetan_history/chapter_1.html).
"THE ORIGIN OF TIBETAN WRITING.....The Tibetan scripts that are in use today came into existence 1,300 years ago when a script known as the Pungyig (spungs yig) of Persia appeared in the country of Zhangzhung, in Ngari....Sam van Schaik) translation of an essay on the Tibetan script by Dungkar Losang Khrinley, from his recent magnum opus, the Dungkar Tibetological Great Dictionary]
Labels: Language
Blogger April 17, 2017 at 12:22 PM
Searching for the Ultimate Dating Website? Create an account to find your perfect date.
Kayanian Dynasty: Kai Kāvus .....(Younger Avestan....
The Nine Ways of Bon...Shamanic and Resultant Leve...
Fravashi & Persian Drala
Sources....Historical Background
Sources...TIBETAN RELIGIONS AND CULTURE
Sources.....Japanese, Shamanism, Native American, ...
Buddharaksita & Tilise from Khotan (433 AD)
Butön & The Second Propagation of Buddhism in Tibe...
Ancient Central Asian Kingdoms: Bakhdhi, Markanda,...
Legendary, Mythical, Mystical, Historical and Magi...
Obi-Rakhmat Grotto (57,000 BC)
Maha Ati & Atiyoga Dzogchen
Neanderthals in Central Asia (30,000 BC)
Africa to Central Asia Migration (50,000 BC)
Kalhana & The Rajatarangini: Chronicle of Kings (1...
Zermig (gZer-mig): Piercing Eye
Shardza Tashi Gyaltsen (1859-1933): Bon & Rimé Mov...
Patrul Rinpoche: Advice from Me to Myself (1808-18...
Cuckoo's Song of Total Presence: The Six Vajra Ve...
Lapis Lazuili Purple in Ancient Central Asia (7th ...
Japanese The Rite Of Nokan & Other Death Rituals
Ultimate Dralas, Higher Beings, Veneration and Off...
Uttarakuru, Mt Meru & Bactria
Abhinavagupta's Critique of the Kalachakra (c.990 ...
Aham, Spiritual Heart, Bodhicitta & the Tantraloka...
Abhinavagupta, Tantrāloka and Kashmir Shaivism (9...
Gonur Tepe: Soma, Haoma, Amrita, Ambrosia (2500 BC...
King Oxyartes of Bactria (2140 BC)
Ancient Eurasian Calendars & Year Zero
The 'Gap', Formlessness & Greek Chaos/Emptiness
Ancient Kings of Central Asia -( 900 BC - 740 AD)
The Avestan-Language and Bactrian Sanskrit...2500 ...
The Kharoṣṭhī Script & Tantric Mantras (300 BC- 40...
Sacred Calligraphy: Ancient Central Asia

redpajama_set_name: RedPajamaCommonCrawl


text:
HISTORY/GEOGRAPHY/SOCIAL STUDIES
HISTORICAL FICTION BOOKS / SERIES
World History / Series Historical Fiction
Bethlehem Books
Living History Series
Show Additional Categories
Junior High - Adult Series (7-AD)
Save: 23.17% ($3.00)
Set in pre-World War I Czechoslovakia, this charming book tells the story of a twelve-year-old girl named Philomena. It has long been the custom for girls in Philomena's village to go to the city to work as housemaids before coming home to be married. Philomena's aunt had gone to the city years ago, but she never returned. On her deathbed, Babushka (Philomena's grandmother) instructs Philomena to go to Prague and find her rich aunt, and perform service in her household. So Philomena sets out on her journey, making friends, gaining experience, and encountering one adventure after another with guidance from her Babushka in Heaven. Charcoal illustrations throughout the story portray the characters and unique setting of Eastern Europe. By Kate Seredy. 96 pgs, pb. ~ Lisa
Category Description for Bethlehem Books:
If you're looking for quality literature to feed the imagination and present history in a readable, enjoyable format, then Bethlehem Books give you many choices. These novels for all ages tell stories of historical fiction about various people and times. The personable characters and richly textured, deeply moving novels from different authors make history come alive in an unforgettable reading experience. Rachel S.
Kate Seredy
0.45 (lbs.)
Philomena-a must read!
This is a great book. My children loved it.
Rebecca C


text:
JOSEF ZLAMAL
Josef Zlamal in press
Josef Zlamal and Andrea Vytlačilová featured in Reflex magazine
Josef Zlamal and Andrea Vytlačilová on TV Nova - Snídaně s Novou
Josef Zlamal a Andrea Vytlačilová ve Snídani s Novou (TV Nova 14.01.2020)
Umění není jen pro znalce a bohaté, říkají módní návrhářka Andrea Vytlačilová a výtvarník Josef Zlamal (Český Rozhlas 18.12.2019)
Každý může následovat svůj sen, to chceme předat dál. Uměním dýcháme a pořád máme české srdce (Český Rozhlas 12.12.2019)
V zahraničí ho srovnávají s mistry renesance: Malíř Josef Zlamal (35) navazuje na rodinnou tradici (Blesk 04.11.2019)
Designérka Vytlačilová a malíř Zlamal: Jaké to je, mít ateliér od šesti let a pracovat pro Marca Jacobse? (Reflex 17.10.2019)
Talent v ateliéru nerozvinete, musíte vyjít ven a komunikovat s lidmi, říká malíř (Lidové noviny 24.9.2019)
Josef Zlamal a Alén Diviš se potkávají na výstavě (Česká Televize 19.08.2019)
Host: mladý výtvarník Josef Zlamal (Český Rozhlas 19.08.2019)
Musel jsem takříkajíc objevit domov skrze pobyty v zahraničí, říká umělec (Metro 18.08.2019)
Existenciální dialog v nadčasových souvislostech (Právo 13.08.2019)
Umělecký pár Andrea Vytlačilová a Josef Zlamal hovoří o své inspiraci i vzájemném ovlivňování (Český Rozhlas 08.08.2019)
Pošmourný svět dvou generací. Galerie U Betlémské kaple zve na dva nadané autory, které dělí půl století (Blesk 07.08.2019)
Debatní klub - Josef Zlamal / Richard Stipl (21.04.2019)
Být dobrý malíř dnes nestačí, říká umělec, jenž se živil i reklamou (Mf Dnes 23.03.2019)
"Lidé nejsou racionální bytosti a my nechceme být prvoplánoví. Emoce je v umění klíčová…" (XTV 02.02.2019)
Interview with Josef Zlamal by Miroslav Ambroz (2016)
Josef Zlamal at Embassy of the Czech Republic in Beijing (2016)
What do you want from art? What do you think is the purpose of art ?
Just as with other professions, the goal is knowledge and understanding, which can be shared with viewers. For me personally, art is about thinking, understanding, ability. This fascinates me with other professions as well.
Can you explain this purpose further? Is it for enjoyment, edification, to provoke, challenge, inspire, motivate, surprise?
To communicate – art for me is a form of communication. It is a universal language, because it works with metaphor, it does not describe. Art is an image, a reflection as it were, of human thought and emotion.
What would you like for other people to experience when they stand before your works?
Everyone interprets what they see in their own perspective, not that of the artist. It is like standing in front of a mirror. I want my work to speak to both the intellect and the emotions of viewers. I strive for a strong visual experience, deep and complex, yet also a clear message that needs no commentary.
It occurs to me that through art we can perceive and feel fragments of the infinite contained inside each one of us. In these rare moments we are able to see something that goes beyond mere physical existence, something greater and sublime, which we might call beauty. The power of real art is in its ability to communicate without words, across time, space, cultures, and also the circumstances of its origin, and perhaps even to transcend meanings that the artist intended but could only subconsciously encode in his works. Do you think the interpretation must be singular?
A single interpretation does not exist. Once my work leaves the studio I have to contend with public reaction, and that can be quite diverse. Most things one sees only in the context of a suggestion taken from somewhere else – that is why the context of the work is important, because it can point to things that are not obvious at first glance.
Every artwork is a refutation of futility. Every human work is a manifestation of human thought – it is an imprint of a specific person, their efforts and actions – conscious as well as subconscious. Nothing happens casually or accidentally, but one needs time and distance to realise the meaning and significance of things.
Creative work is fascinating. It has no ceiling and sometimes even no floor. Certain themes have been recurring for hundreds of years, but what is always fascinating is the authenticity in conveying the interpretation – the individual perspective on a thing.
Do real works of art even need some kind of interpretation?
If you share something about the source of inspiration with the public, then you can greatly speed up communication, or, rather, how people perceive the work, realising that what the artist knows intimately is at first entirely new to them, sometimes even strange. Interpretation is not a necessity, but it is enriching. A work without a viewer has no sense. It is precisely this interaction that turns it into a living thing.
It is often said that time is essential for proving the value of a work and to show that it is not merely a fad connected to its moment in history.
Time certainly brings objectivity, helps a person to see real connections, because it depersonalises it. Fads are a completely normal part of the art world. Every thing needs its flip side.
Yet today's art scene seems to have given up on permanence and credibility founded on truly lived experience, pursuit of "eternity" – qualities bound with art (but also music, architecture, literature …) of the past.
Art is a reflection of its time. Non-professionalism, dilettantism, bouncing from one thing to another, lack of commitment, fecklessness? The possibilities today are endless – like a river where we can find everything imaginable. But this is no reason to succumb to skepticism. Each person chooses for themselves what they want, and they alone carry the responsibility for what they do and how they do it. Everyone has to find their own approach.
The moment is everything, quick fame is the goal. How do you see this schism?
There are a lot of things I do not have an opinion about, because I am trying to concentrate only on what I can influence myself, and trends and currents are definitely not among them.
Do the works of Old Masters pulse with energy for you, or do you see them as "dead" and far from the modern man's pursuit of feeling?
They are a great challenge and motivation for me as well as a source of inspiration and edification. A large number of the works are as current as if they were made yesterday or today, even after hundreds of years. What determines the timelessness of a work is not when it was made but its message.
In my working environment I am surrounded by the works of other artists, especially those from the Middle Ages. In my opinion it was precisely at this time that fine art reached its peak in many ways, and naturally a person measures their own work against what they think are the very best ones.
A close friend of mine, who is in his 70s, once told me that I lead a dialogue with the dead through the artworks they have left behind. This is a privilege of the creative professions. Traces of artists remain even after their death.
Life is unfair, the art world is unbalanced. If a person dies having created work just about themselves and for themselves, is it not a sign of idiosyncratic genius striding through time?
The intellect is for a person to be able to orientate themselves. In the end, a person has the place that they have earned and deserve. The only reality is the one we live in. In my opinion, creative work has always been about dividing time between work in the studio and outside of it. Ignorance is, I think, more a sign of stupidity rather than uniqueness.
Today's conceptual art is often accompanied by extensive commentary. I suppose it is fine if an artist wants to write about their work, to inform and raise questions. Words can provide a broader context, but they can also get in the viewer's way. The artist probably should not feel the need to explain everything or justify their work. Concise and intelligent writing enhances understanding of the work for the viewer and could be an introduction to the artist's way of thinking. But if words are always needed to explain a piece of art, something obviously is not right.
Exercising creative effort is a recognition of the fact that no one ever solves anything for the artist – it is about realising one's own responsibility. Respect and esteem must be built; it is as long a process as the creative journey itself.
Lately (I mean, roughly, for the past 20 years), it seems to me there has been a growing tendency towards something disturbing the sense of safety and certainty that humans crave. Your work seems to be a response to that threat, but maybe it is just my feeling. What exactly are your sources of inspiration?
There are three main sources of inspiration. Literature, film and medieval art. If I had to choose three key artists, they would be Friedrich Dürrenmatt, Carl Theodor Dreyer and Matthias Grünewald.
You exhibit with Richard Stipl quite regularly. Your drawings and his sculptures complement each other extraordinarily well and create a harmonious whole. How did this consonance originate, what was its genesis?
It happened quite naturally. We were both born in the same town, Šternberk. Richard and I met when we were just 9 years old during his first visit to post-revolution Czechoslovakia; his parents had emigrated to Canada in 1980. So we have known each other for more than 20 years. But our joint work started only in 2012 with an exhibition in Istanbul. It was there that we realised our work complements and enhances the other's. Since then we have come a long way. Today, we can speak of a creative symbiosis. We share a studio, and my ink drawings have now completely meshed with Richard's sculptures.
Can you tell me how your works originate – what is your process?
At first there is always studying – the preparatory stage, a long process of gathering images and information. Only then do I start to make sketches, which are an essential part of my work. In my studio there are hundreds of them. It is these that I subsequently compose my drawing from. Some of them I then soak in a water bath. This is accompanied by a process of gradual layering that may recall a medieval palimpsest. My main medium is black ink on handmade paper. Recently, I started adding wood, both in the case of Richard's sculpture and the wooden boards on which I have recently started to draw.
It seems that the two dimensions of drawing are not enough and that you want to achieve a stronger effect by moving into the third dimension. What further departures from drawing do you see for your work?
Drawing is key for me, it is essential to the entire body of my work. I see new horizons in stage design, installation, working with space. But also video, which can convey the content of my drawings to a wider audience, as with William Kentridge.
You are often exhibiting at prestigious international art fairs along with Richard Stipl. What kind of reactions are you receiving and how has the experience been for you?
Contact with the public is vital. It is a mirror which moves a person forward intellectually. An artwork without an audience or interaction has no sense, in fact it does not really exist. I really value the opportunity of international contact. Every trip abroad brings my experience up a notch.
I wish you much luck with this. Thank you for the interview.
Copyright © 2023 Josef Zlamal. All rights reserved.