async def parse_toc(self, version: Version, toc: List[Dict[str, Any]], path: str): await self.delete_all_from_version(version) position = 0 for elem in toc: name = elem['name'] with open(paths.join(path, f'{name}.md')) as f: content = f.read() article = await self.create({ 'name': name, 'position': position, 'lang': blnt.init['default_lang'], 'markdown': content, 'html': self._read_markdown(content), 'version': version }) await self.content_service.parse_article_toc(article) for lang in elem.get('languages', []): with open(paths.join(path, f'{name}.{lang}.md')) as f: content = f.read() article = await self.create({ 'name': name, 'position': position, 'lang': lang, 'markdown': content, 'html': self._read_markdown(content), 'version': version }) await self.content_service.parse_article_toc(article) position += 1
async def _download_and_extract(self, path: str, archive_url: str): if not paths.exists(path): paths.mkdir(path) with open(paths.join(path, 'archive.tar.gz'), 'wb') as archive: response = requests.get(archive_url) archive.write(response.content) with tarfile.open(paths.join(path, 'archive.tar.gz'), 'r:gz') as archive: archive.extractall(path)
async def _process_docs(self, version: Version, path: str): for file in os.listdir(path): file_path = paths.join(path, file) app_path = paths.join(path, file, 'docs') if os.path.isdir(file_path) and paths.exists(app_path): with open(paths.join(app_path, 'docs.yaml'), 'r') as doc_config: config = yaml.safe_load(doc_config) await self.article_service.parse_toc(version, config.get('toc', []), app_path)
def _get_blnt_instance(console: Console, path: str): module_name = _find_module(path) if module_name is not None and paths.exists(paths.join(path, module_name)): if path not in sys.path: sys.path.append(path) module = importlib.import_module(module_name) main_func = next( iter( [ f for f in module.__dict__.values() if callable(f) and getattr(f, "__blnt__", None) == "__blnt_main__" ] ), None, ) if main_func is None: console.error( f"No main func found in {module_name} module. " "Make sure to import a @main_func decorated function in the module's __init__.py file." ) sys.exit(1) instance = main_func() if not isinstance(instance, Bolinette): console.error("The main_func did not return a Bolinette instance.") sys.exit(1) return instance return Bolinette(_anonymous=True)
def read_manifest(path, *, params: dict[str, Any] = None): try: with open(paths.join(path, "manifest.blnt.yaml")) as f: raw = f.read() if params is not None: for param in params: raw = raw.replace(f"__{param}__", params[param]) return yaml.safe_load(raw) except FileNotFoundError: return None
def _create_file( console: Console, *, source_dir: str, source_template: str, dest_dir: str, dest_file: str, params: dict[str, Any], ): if not paths.exists(dest_dir): console.error( f"Folder {dest_dir} not found.\n" "Make sure you have set the module in the manifest or you are " "using the CLI at project root directory.") sys.exit(1) dest = paths.join(dest_dir, dest_file) if paths.exists(dest): console.error(f"File {dest} already exist.") sys.exit(1) rendered = files.render_template(source_dir, source_template, params) files.write(dest, rendered)
def render_template(self, name: str, params: dict = None, workdir: str = None, *, status=200): if workdir is None: workdir = self.context.templates_path() if params is None: params = {} for key, value in self.context.manifest.items(): if key not in params: params[key] = value try: content = files.render_template(workdir, name, params) except TemplateNotFound: error_404_wd = self.context.internal_files_path("templates") error_404 = paths.join("errors", "404.html.jinja2") content = files.render_template(error_404_wd, error_404, params) status = 404 return AioResponse(body=content, status=status, content_type="text/html")
def read_requirements(path): try: with open(paths.join(path, "requirements.txt")) as f: return list(filter(lambda r: len(r), f.read().split("\n"))) except FileNotFoundError: return []
async def write_file(self, content, key): path = self.context.instance_path("uploads") if not paths.exists(path): paths.mkdir(path) with open(paths.join(path, key), "wb") as f: f.write(content)
def root_path(self, *path): return paths.join(self._cwd, *path)
def internal_files_path(self, *path): return paths.join(self._origin, "_files", *path)
def internal_path(self, *path): return paths.join(self._origin, *path)
def _update_init(path: str, module: str, folder: str, name: str, class_name: str): file_path = paths.join(path, "__init__.py") files.write(file_path, f"from {module}.{folder}.{name} import {class_name}\n", mode="a+")
def _cwd_path(*path): return paths.join(paths.cwd(), *path)
from bolinette.utils import files, paths from setuptools import setup, find_packages from bolinette import core context = core.BolinetteContext( paths.join(paths.dirname(__file__), 'bolinette')) def project_packages(module): return [m for m in find_packages() if m.startswith(module)] setup(name='Bolinette', packages=project_packages('bolinette'), include_package_data=True, version=context.manifest['version'], license='MIT', description='An asynchronous Python web framework', long_description=files.read_file(context.root_path('README.md')), long_description_content_type='text/markdown', author='Pierre Chat', author_email='*****@*****.**', url='https://github.com/TheCaptainCat/bolinette', keywords=['Bolinette', 'Web', 'Framework', 'Async'], install_requires=files.read_requirements(context.root_path()), classifiers=[ 'Development Status :: 4 - Beta', 'Intended Audience :: Developers', 'Topic :: Software Development :: Build Tools', 'License :: OSI Approved :: MIT License',
async def _parse_legends_plus(self, path: str, region: str, parse_only: typing.List[str] = None): file_path = paths.join(path, f'{region}-legends_plus.xml') await self._parse_legends_file(file_path, parse_only)