Merge pull request #34 from kinegratii/dev

Release v0.5.2

Author: kinegratii

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+  - package-ecosystem: pip
+    directory: "/"
+    schedule:
+      interval: daily
+    target-branch: "dev"

.github/workflows/unittest.yaml

@@ -28,6 +28,7 @@ jobs:
           pip install borax>=3.5
           pip install pyecharts~=1.9
           pip install typing_extensions~=4.0
+          pip install htmlgenerator~=1.2
           pip install flake8~=3.9
           pip install nose2~=0.10
       - name: Lint with flake8

MANIFEST.in

@@ -1,4 +1,4 @@
-recursive-include django_echarts/templates/ *.tpl *.py *.html
+recursive-include django_echarts/templates *.tpl *.py *.html
 include django_echarts/contrib/*.html
 include django_echarts/contrib/*/*.html
 include django_echarts/contrib/*/*/*.html

README.md

@@ -140,6 +140,8 @@ Build on [Material for MkDocs](https://squidfunk.github.io/mkdocs-material/)
 
 ## 示例项目(Demo Project)
 
+在线示例 [https://zinc.pythonanywhere.com](https://zinc.pythonanywhere.com) 
+
 参见项目 [kinegratii/zinc](https://github.com/kinegratii/zinc) 。
 
 ## 截图(Screen Shots)

django_echarts/__init__.py

@@ -2,5 +2,5 @@
 A django app for Echarts integration with pyecharts as chart builder.
 """
 
-__version__ = '0.5.1'
+__version__ = '0.5.2'
 __author__ = 'kinegratii'

django_echarts/conf.py

@@ -3,7 +3,7 @@
 """
 Expose the settings objects.
 """
-
+import os
 from django.conf import settings
 from django.utils.functional import SimpleLazyObject
 
@@ -14,13 +14,20 @@
 
 def get_django_echarts_settings():
     project_echarts_settings = getattr(settings, 'DJANGO_ECHARTS', {})
+    static_url = settings.STATIC_URL
+    if settings.STATICFILES_DIRS:
+        staticfiles_dir = str(settings.STATICFILES_DIRS[0])
+    else:
+        staticfiles_dir = os.path.join(str(settings.BASE_DIR), 'static')
     extra_settings = {
         'STATIC_URL': settings.STATIC_URL,
         'STATICFILES_DIRS': settings.STATICFILES_DIRS
     }
     settings_store = SettingsStore(
         echarts_settings=project_echarts_settings,
-        extra_settings=extra_settings
+        extra_settings=extra_settings,
+        static_url=static_url,
+        staticfiles_dir=staticfiles_dir
     )
     return settings_store
 

django_echarts/core/dms.py

@@ -2,27 +2,14 @@
 """
 A Implement that you can use host name instead of its url.
 """
-from typing import Tuple
+from typing import Tuple, List
 
 from pyecharts.datasets import FILENAMES, EXTRA
+from django_echarts.utils.burl import BUrl
+from .localfiles import LocalFilesMixin, DownloaderResource
 
 __all__ = ['DependencyManager']
 
-
-def pyecharts_resolve_dep_name(dep_name: str) -> Tuple[bool, str]:
-    if dep_name.startswith("https://") or dep_name.startswith('http://'):
-        return True, dep_name
-    if dep_name in FILENAMES:
-        f, ext = FILENAMES[dep_name]
-        return False, "{}.{}".format(f, ext)
-    else:
-        for url, files in EXTRA.items():
-            if dep_name in files:
-                f, ext = files[dep_name]
-                return False, "{}.{}".format(f, ext)
-        return False, '{}.js'.format(dep_name)
-
-
 # The repo contains all dependencies
 _BUILTIN_REPOS_ = {
     'pyecharts': 'https://assets.pyecharts.org/assets/',
@@ -51,12 +38,13 @@ def d2f(dep_name: str):
         return f'{dep_name}.js'
 
 
-class DependencyManager:
+class DependencyManager(LocalFilesMixin):
     def __init__(self, *, context: dict = None, repo_name: str = None):
         self._context = context or {}
         self._repo_dic = {}
         self._custom_dep2url = {}  # depname=> url
         self._cur_repo_name = repo_name
+        self._baidu_map_ak = self._context.get('baidu_map_ak')
 
     def add_repo(self, repo_name: str, repo_url: str):
         self._repo_dic[repo_name] = repo_url
@@ -70,12 +58,13 @@ def _resolve_dep(self, dep_name: str, repo_name: str = None) -> Tuple:
             if value.startswith('#'):
                 repo_name = value[1:]
             else:
+                value = value.format(**self._context)
                 return value, d2f(dep_name)
         repo_name = repo_name or self._cur_repo_name
         if repo_name not in self._repo_dic:
             raise ValueError(f'Unknown dms repo: {repo_name}. Choices are:{",".join(self._repo_dic.keys())}')
 
-        use_url, new_dep_name = pyecharts_resolve_dep_name(dep_name)
+        use_url, new_dep_name = self._pyecharts_resolve_dep_name(dep_name)
         if use_url:
             return new_dep_name, None
         filename = d2f(new_dep_name)
@@ -87,11 +76,35 @@ def resolve_url(self, dep_name: str, repo_name: str = None) -> str:
         url, _ = self._resolve_dep(dep_name, repo_name)
         return url
 
-    def iter_download_resources(self, dep_names: str, repo_name: str = None):
+    def get_download_resources(self, dep_names: List[str], repo_name: str = None) -> List[DownloaderResource]:
+        resources = []
         for dep_name in dep_names:
             url, filename = self._resolve_dep(dep_name, repo_name)
-            if filename:
-                yield dep_name, url, filename
+            local_ref_url, local_path = self.localize_url(filename)
+            resources.append(
+                DownloaderResource(url, local_ref_url, local_path, label=dep_name, catalog='Dependency')
+            )
+        return resources
+
+    def _pyecharts_resolve_dep_name(self, dep_name: str) -> Tuple[bool, str]:
+        if all([
+            self._baidu_map_ak,
+            dep_name.startswith('https://api.map.baidu.com/') or dep_name.startswith('http://api.map.baidu.com/'),
+            'ak=' in dep_name
+        ]):
+            # Replace baidu map ak with global settings.
+            return True, BUrl(dep_name).replace('ak', self._baidu_map_ak).url
+        if dep_name.startswith("https://") or dep_name.startswith('http://'):
+            return True, dep_name
+        if dep_name in FILENAMES:
+            f, ext = FILENAMES[dep_name]
+            return False, "{}.{}".format(f, ext)
+        else:
+            for url, files in EXTRA.items():
+                if dep_name in files:
+                    f, ext = files[dep_name]
+                    return False, "{}.{}".format(f, ext)
+            return False, '{}.js'.format(dep_name)
 
     @classmethod
     def create_default(cls, context: dict = None, repo_name: str = None):

django_echarts/core/localfiles.py

@@ -0,0 +1,30 @@
+from typing import Tuple
+import os
+
+
+class DownloaderResource:
+    def __init__(self, remote_url, ref_url, local_path, label=None, catalog=None, exists=False):
+        self.remote_url = remote_url
+        self.ref_url = ref_url
+        self.local_path = local_path
+        self.label = label or ''
+        self.catalog = catalog or ''
+        self.exists = exists
+
+
+class LocalFilesMixin:
+    def set_localize_opts(self, static_url, staticfiles_dir):
+        """Set options for localize_opts"""
+        self._localize_opts = {
+            'static_url': static_url,
+            'staticfiles_dir': staticfiles_dir
+        }
+
+    def url2filename(self, url, **kwargs) -> str:
+        pass
+
+    def localize_url(self, filename: str) -> Tuple[str, str]:
+        """Return local ref url and local file path from a remote url."""
+        local_ref_url = self._localize_opts['static_url'] + filename
+        local_path = os.path.join(self._localize_opts['staticfiles_dir'], filename)
+        return local_ref_url, local_path

django_echarts/core/settings_store.py

@@ -25,6 +25,8 @@ class DJEOpts:
     theme_d2u: Optional[Dict] = None
     site_class: Optional[str] = None
 
+    baidu_map_ak: str = None
+
     def get_echarts_theme(self, instance_theme) -> str:
         if self.echarts_theme:
             return self.echarts_theme
@@ -59,11 +61,14 @@ def _u(_old, _new=None):
 
 # SettingsStore -> DependencyManage -> DJEOpts
 class SettingsStore:
+    """A settings entry for dms and tms."""
 
     def __init__(self, *, echarts_settings=None, extra_settings=None, **kwargs):
         # Pre check settings
 
         self._extra_settings = extra_settings or {}
+        self.static_url = kwargs.get('static_url', '/static/')
+        self.staticfiles_dir = kwargs.get('staticfiles_dir', '')
 
         if isinstance(echarts_settings, dict):
             new_opts = DJEOpts.upgrade_dict(echarts_settings)
@@ -75,19 +80,24 @@ def __init__(self, *, echarts_settings=None, extra_settings=None, **kwargs):
         else:
             self._opts = DJEOpts()
 
-        context = {'echarts_version': self._opts.echarts_version}
+        context = {
+            'echarts_version': self._opts.echarts_version,
+            'baidu_map_ak': self._opts.baidu_map_ak
+        }
         if 'STATIC_URL' in self._extra_settings:
-            context.update({'STATIC_URL': self._extra_settings['STATIC_URL']})
+            context.update({'STATIC_URL': self.static_url})
         self._dms = DependencyManager.create_default(
             context=context,
             repo_name=self._opts.dms_repo
         )
         self._dms.load_from_dep2url_dict(self._opts.dep2url)
+        self._dms.set_localize_opts(static_url=self.static_url, staticfiles_dir=self.staticfiles_dir)
 
         user_theme_label, user_theme_app = self._auto_get_theme_params()
         if not self._opts.theme_app:
             self._opts.theme_app = user_theme_app
-        self._tms = ThemeManager.create_from_module(theme_app=user_theme_app)
+        self._tms = ThemeManager.create_from_module(theme_app=user_theme_app, d2u=self._opts.theme_d2u)
+        self._tms.set_localize_opts(static_url=self.static_url, staticfiles_dir=self.staticfiles_dir)
 
         self._theme = self._tms.create_theme(user_theme_label)
 
@@ -109,17 +119,14 @@ def theme_manger(self) -> ThemeManager:
     def theme(self) -> Theme:
         return self._theme
 
-    def resolve_url(self, dep_name: str, repo_name: Optional[str] = None):
+    def resolve_url(self, dep_name: str, repo_name: Optional[str] = None) -> str:
         return self._dms.resolve_url(dep_name, repo_name)
 
     def generate_js_link(self, js_name, js_host=None, **kwargs):
         warnings.warn('The method SettingsStore.generate_js_link is deprecated, use SettingsStore.resolve_url instead.',
                       DeprecationWarning, stacklevel=2)
         return self._dms.resolve_url(dep_name=js_name, repo_name=js_host)
 
-    def get(self, key, default=None):
-        return getattr(self._opts, key, default)
-
     def get_site_obj(self):
         if not self._opts.site_class:
             raise TypeError('The settings DJANGO_ECHARTS.site_class is required for this feature.')

django_echarts/core/tms.py

@@ -2,6 +2,8 @@
 from collections import OrderedDict
 from typing import List, Dict
 
+from .localfiles import LocalFilesMixin, DownloaderResource
+
 __all__ = ['Theme', 'parse_theme_label', 'ThemeManager']
 
 _ORDERED_FIELDS_ = ['base_css', 'main_css', 'palette_css', 'font_css', 'jquery_js', 'main_js']
@@ -57,30 +59,11 @@ def set_file_url(self, url: str, name: str):
     def set_cns(self, cns):
         self.cns.update(cns)
 
-    def iter_local_paths(self):
-        for name in self._url_dic.keys():
-            url, local_path = self._localize_url(name)
-            yield name, url, local_path
-
-    def _localize_url(self, name: str, as_url=False):
-        url = self._url_dic[name]
-        if name == 'palette_css':
-            local_path = '/'.join([self.name, self.theme_palette]) + '.min.css'
-        else:
-            filepath = url.rsplit('/')[-1]
-            local_path = self.name + '/' + filepath
-        if as_url:
-            local_path = '/static/' + local_path
-        return url, local_path
-
-    def local_theme(self) -> 'Theme':
-        new_theme = Theme(self.theme, self.theme_palette, is_local=True)
-        new_theme.cns = self.cns
+    def iter_name_and_url(self):
         for name, url in self._url_dic.items():
-            new_theme.set_file_url(self._localize_url(name)[1], name)
-        return new_theme
+            yield name, url
 
-    def list_staticfiles(self):
+    def list_urls(self):
         yield from self.css_urls
         yield from self.js_urls
 
@@ -95,7 +78,7 @@ def module2dict(module_path: str) -> dict:
     return settings_dict
 
 
-class ThemeManager:
+class ThemeManager(LocalFilesMixin):
     def __init__(self, theme_app_config: dict = None, file2url: Dict = None):
         self.theme_app_config = theme_app_config or {}
         self.theme_name = theme_app_config.get('NAME')
@@ -123,9 +106,9 @@ def _palette_css(_url):
                 theme_obj.set_file_url(_url.format(palette=palette), 'palette_css')
 
         for f in _ORDERED_FIELDS_:
-            val = static_dic.get(f)
+            val = self.get_custom_url(theme_palette, f)
             if not val:
-                val = self.get_custom_url(theme_palette, f)
+                val = static_dic.get(f)
             if not val:
                 continue
             if f == 'main_css':
@@ -163,11 +146,40 @@ def _get(_f, _v):
         _get('size', size)
         return ' '.join(cns)
 
+    def url2filename(self, url, **kwargs) -> str:
+        name = kwargs.get('name')
+        theme = kwargs.get('theme')  # type:Theme
+        if name == 'palette_css':
+            filename = '/'.join([theme.name, theme.theme_palette]) + '.min.css'
+        else:
+            filepath = url.rsplit('/')[-1]
+            filename = theme.name + '/' + filepath
+        return filename
+
+    def localize_theme(self, theme: Theme) -> Theme:
+        if theme.is_local:
+            return theme
+        new_theme = Theme(theme.theme, theme.theme_palette, is_local=True)
+        new_theme.cns = theme.cns
+        for name, url in theme.iter_name_and_url():
+            filename = self.url2filename(url, name=name, theme=theme)
+            new_theme.set_file_url(self.localize_url(filename)[0], name)
+        return new_theme
+
+    def get_download_resources(self, theme: Theme) -> List[DownloaderResource]:
+        resources = []
+        for name, url in theme.iter_name_and_url():
+            filename = self.url2filename(url, name=name, theme=theme)
+            local_ref_url, local_path = self.localize_url(filename)
+            resources.append(DownloaderResource(url, local_ref_url, local_path, label='', catalog=name))
+        return resources
+
     @property
     def available_palettes(self) -> List[str]:
         return [self.theme_name] + [f'{self.theme_name}.{p}' for p in self._available_palettes]
 
     @classmethod
     def create_from_module(cls, theme_app: str, d2u: dict = None):
+        """Create a theme manager with config module."""
         theme_app_config = module2dict(f'{theme_app}.config')
         return cls(theme_app_config, d2u)