def test_flatten_url_tree_url_import_with_routers(self):

        class MockApiViewSet(ModelViewSet):
            serializer_class = CommentSerializer
            model = User

        class AnotherMockApiViewSet(ModelViewSet):
            serializer_class = CommentSerializer
            model = User

        router = DefaultRouter()
        router.register(r'other_views', MockApiViewSet)
        router.register(r'more_views', MockApiViewSet)

        urls_app = patterns('', url(r'^', include(router.urls)))
        urls = patterns(
            '',
            url(r'api/', include(urls_app)),
            url(r'test/', include(urls_app))
        )
        urlparser = UrlParser()
        apis = urlparser.get_apis(urls)

        self.assertEqual(sum(api['path'].find('api') != -1 for api in apis), 4)
        self.assertEqual(sum(api['path'].find('test') != -1 for api in apis), 4)

class Restify(object):

    def __init__(self):
        # get restify specific settings
        self.settings = getattr(settings, 'RESTIFY', {})

        self.IGNORE_LIST = ['^django*', '^api$', '^rest_framework*',
                            '^auth*'] + self.settings.get('IGNORE_LIST', [])
        self.router = None
        self.viewsets = {}   # viewsets
        self.apps()

    def slugify(self, value):
        try:
            value = unicodedata.normalize('NFKD', value).encode(
                'ascii', 'ignore').decode('ascii')
        except:
            pass
        value = re.sub('[^\w\s-]', '', value).strip().lower()

        return re.sub('[-\s]+', '-', value)

    def get_apps(self):
        return apps.app_configs

    def apps(self):
        all_apps = self.get_apps()
        MODELS = self.settings.get('MODELS', None)

        for app, app_config in all_apps.items():
            # Check if user is in ignored list
            found = [ignore_pattern for ignore_pattern in self.IGNORE_LIST
                     if re.findall(ignore_pattern, app_config.name)]
            if found:
                continue

            for model in app_config.get_models():
                if MODELS and model._meta.model_name not in MODELS:
                    continue

                url = self.slugify(model._meta.verbose_name_plural.title())
                view = Views()
                viewset = view.get_viewsets(model)

                self.viewsets[url] = viewset

    def register(self):
        self.router = DefaultRouter()
        for url, viewset in self.viewsets.items():
            self.router.register(url, viewset)

        # special case fo User model
        user_viewset = get_user_viewset()
        self.router.register('users', user_viewset)

        return self.router

    def router(self):
        return self.router

 def setUp(self):
     router = DefaultRouter()
     router.register('example1', Http404ExampleViewSet, base_name='example1')
     router.register('example2', PermissionDeniedExampleViewSet, base_name='example2')
     self.patterns = [
         url('^example/?$', ExampleListView.as_view()),
         url(r'^', include(router.urls))
     ]

class TestNameableRoot(TestCase):
    def setUp(self):
        class NoteViewSet(viewsets.ModelViewSet):
            model = RouterTestModel
        self.router = DefaultRouter()
        self.router.root_view_name = 'nameable-root'
        self.router.register(r'notes', NoteViewSet)
        self.urls = self.router.urls

    def test_router_has_custom_name(self):
        expected = 'nameable-root'
        self.assertEqual(expected, self.urls[0].name)

class TestRootWithAListlessViewset(TestCase):
    def setUp(self):
        class NoteViewSet(mixins.RetrieveModelMixin, viewsets.GenericViewSet):
            model = RouterTestModel

        self.router = DefaultRouter()
        self.router.register(r"notes", NoteViewSet)
        self.view = self.router.urls[0].callback

    def test_api_root(self):
        request = factory.get("/")
        response = self.view(request)
        self.assertEqual(response.data, {})

class TestNameableRoot(TestCase):
    def setUp(self):
        class NoteViewSet(viewsets.ModelViewSet):
            queryset = RouterTestModel.objects.all()

        self.router = DefaultRouter()
        self.router.root_view_name = 'nameable-root'
        self.router.register(r'notes', NoteViewSet)
        self.urls = self.router.urls

    def test_router_has_custom_name(self):
        expected = 'nameable-root'
        assert expected == self.urls[-1].name

class GeoModelViewSetTestCase(SimpleQueryTestCase):
    def setUp(self):
        self.router = DefaultRouter()
        self.router.register(r'locations', LocationViewSet)
        self.view = LocationViewSet.as_view({'get': 'list'})

    def test_renderer(self):
        request = factory.get('/locations/',
                              HTTP_ACCEPT=GeoJSONRenderer.media_type)
        response = self.view(request)
        self.assertIsInstance(response.accepted_renderer, GeoJSONRenderer)

    def test_register(self):
        self.assertGreater(len(self.router.urls), 0)

    def test_exclude_router_api_root(self):
        class MyViewSet(ModelViewSet):
            serializer_class = CommentSerializer
            model = User

        router = DefaultRouter()
        router.register('test', MyViewSet)

        urls_created = len(router.urls)

        parser = UrlParser()
        apis = parser.get_apis(router.urls)

        self.assertEqual(4, urls_created - len(apis))

class RasterViewSetTestCase(SimpleTestCase):
    def setUp(self):
        self.router = DefaultRouter()
        self.router.register(r'rasters', RasterViewSet)
        self.view = RasterViewSet.as_view({'get': 'list'})

    def test_renderer(self):
        request = factory.get('/rasters/',
                              HTTP_ACCEPT=GeoTIFFZipRenderer.media_type)
        response = self.view(request)
        self.assertEqual(response['Content-Type'],
                         GeoTIFFZipRenderer.media_type)

    def test_register(self):
        self.assertGreater(len(self.router.urls), 0)

    def setUp(self):
        class NoteViewSet(mixins.RetrieveModelMixin, viewsets.GenericViewSet):
            model = RouterTestModel

        self.router = DefaultRouter()
        self.router.register(r"notes", NoteViewSet)
        self.view = self.router.urls[0].callback

 def setUp(self):
     class NoteViewSet(viewsets.ModelViewSet):
         model = RouterTestModel
     self.router = DefaultRouter()
     self.router.root_view_name = 'nameable-root'
     self.router.register(r'notes', NoteViewSet)
     self.urls = self.router.urls

    def register(self):
        self.router = DefaultRouter()
        for url, viewset in self.viewsets.items():
            self.router.register(url, viewset)

        # special case fo User model
        user_viewset = get_user_viewset()
        self.router.register('users', user_viewset)

        return self.router

    def test_flatten_url_tree_url_import_with_routers(self):
        class MockApiViewSet(ModelViewSet):
            serializer_class = CommentSerializer
            model = User

        class AnotherMockApiViewSet(ModelViewSet):
            serializer_class = CommentSerializer
            model = User

        router = DefaultRouter()
        router.register(r"other_views", MockApiViewSet)
        router.register(r"more_views", MockApiViewSet)

        urls_app = patterns("", url(r"^", include(router.urls)))
        urls = patterns("", url(r"api/", include(urls_app)), url(r"test/", include(urls_app)))
        urlparser = UrlParser()
        apis = urlparser.get_apis(urls)

        self.assertEqual(sum(api["path"].find("api") != -1 for api in apis), 4)
        self.assertEqual(sum(api["path"].find("test") != -1 for api in apis), 4)

def get_router():
    """
    Get a Django REST Framework router instance with all viewsets.

    :rtype: rest_framework.routers.DefaultRouter
    """
    router = DefaultRouter()
    router.register(r'projects', ProjectViewSet)
    router.register(r'issues', IssueViewSet)
    router.register(r'comments', CommentViewSet)
    return router

from django.conf import settings
from django.conf.urls import include, url

from rest_framework.routers import DefaultRouter

from .views import DiscretizedDataPointViewSet


router = DefaultRouter()
router.register(r'discretized_data_points', DiscretizedDataPointViewSet)

urlpatterns = [
    url(r'^api/' + settings.API_VERSION + '/', include(router.urls)),  # TODO makes sense to have a settings.API_BASE_URL rather than a settings.API_VERSION?
]

from django.conf.urls import patterns, url, include
from django.contrib import admin
from rest_framework.routers import DefaultRouter
import views

router = DefaultRouter()
router.register(r'learningrecord', views.LearningRecordViewSet)
router.register(r'socialrelationship', views.SocialRelationshipViewSet)
router.register(r'classification', views.ClassificationViewSet)
router.register(r'userclassification', views.UserClassificationViewSet)
#router.register(r'sna', views.SNARESTView, base_name="sna")

urlpatterns = patterns('',
    url(r'^register/$', views.register, name='register'),
    url(r'^eventregistration/$', views.eventregistration, name='eventregistration'),
    url(r'^socialmediaaccounts/$', views.socialmediaaccounts, name='socialmediaaccounts'),
    url(r'^sna/$', views.SNARESTView.as_view(), name='sna'),
    url(r'^wordcloud/$', views.WORDCLOUDView.as_view(), name='wordcloud'),
    url(r'^classificationpie/$', views.CLASSIFICATIONPieView.as_view(), name='classificationpie'),
    url(r'^topicmodel/$', views.TOPICMODELView.as_view(), name='topicmodel'),
    url(r'^classify/$', views.MLCLASSIFY.as_view(), name='classify'),
    url(r'^train/$', views.MLTRAIN.as_view(), name='train'),
    url(r'^externallinklog/$', views.EXTERNALLINKLOGView.as_view(), name='externallinklog'),
)

from django.conf.urls import url, include
from rest_framework.routers import DefaultRouter

from main.api import views
router = DefaultRouter()
router.register('games', views.GameViewSet)
router.register('users', views.UserViewSet)

urlpatterns = [
    url('^index/', views.Index.as_view()),
    url('^login/', views.Login.as_view()),
    url('^logout/', views.Logout.as_view()),
    url('^check_auth/', views.CheckAuthentication.as_view()),

    url('^hi_scores/', views.GetHiScoreTop.as_view()),

    url(r'', include(router.urls)),
]

from rest_framework.routers import DefaultRouter
from Formularios.api.views import FormularioViewSet

from django.conf.urls import patterns, url, include

router = DefaultRouter()
router.register(r'formulario', FormularioViewSet)

urlpatterns = patterns('',
    url(r'^', include(router.urls)),
    )

from snippets import views
from rest_framework.routers import DefaultRouter

urlpatterns = [
    url(r'^admin/', include(admin.site.urls), name='admin'),
    url(r'^home/$', HomePageView.as_view(), name='home'),
    url(r'^dashboard/1', DisplayOneView.as_view(), name='display1'),
    url(r'^dashboard/2', DisplayTwoView.as_view(), name='display2'),
    #url(r'^saltDemo/', SaltTestView.as_view(), name='display3'),
    #url(r'^zabbixDemo/', ZabbixDemoView.as_view(), name='display4'),
    url(r'^jqGridDemo/', jqGridDemoView.as_view(), name='display5'),
    url(r'^testSerializer/', serializerModule, name='serializerModule'),
    
    # 
    url(r'^at/', include('amazingTable.urls')),
]

router = DefaultRouter()
router.register(r'snippets', views.SnippetViewSet)
router.register(r'users', views.UserViewSet)
router.register(r'contents', views.ContentViewSet)

urlpatterns += [
    url(r'^', include(router.urls)),
    url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework'))
]
#AJAX
#urlpatterns += [
#    url(r'^saltajaxtest/', ajax_get_minion_statu, name='ajax_get_minion_statu'),
#]

from valve_insulation import views

from django.conf.urls import url, include

from rest_framework import renderers
from rest_framework.routers import DefaultRouter
from rest_framework.urlpatterns import format_suffix_patterns

# Create a router and register our viewsets with it.
router = DefaultRouter()
router.register(r'valve_insulation', views.ValveInsulationViewSet)

urlpatterns = [
        url(r'^', include(router.urls))
]