Saravanan666/pypi-org huggingface dataset:
Package: jiushu_logger
jiushu-logger【九书】简介JF 专用格式化 logger。听说有个人叫【九哥】，那我这个项目叫【九叔】很合理吧。（谐音梗扣钱！）使用方法引入包内所有内容：fromjiushu_loggerimport*使用包内的Logger类写日志，该类中包含biz、req、call、cron、middleware、mq等六种日志格式。
同时每种日志格式都有对应属于自己的extra参数配置。使用方法如下：（注意：req 日志是专用于 flask 和 starlette 插件包的，不供开发者自行使用。）fromjiushu_loggerimport*# 所有类型的日志均有 trace_id 和 duration 两项，但 trace_id 和 duration 均为非必需，duration 以秒为单位Logger.biz.info('一个biz日志',extra=BizLogExtra(trace_id='xxx',duration=123.456))# call 日志分为 INTERN 、 EXTERN 两种Logger.call.warning('call警告',extra=CallLogExtra(type=CallType.EXTERN,params={'input':'value1'},resp={'output':'value2'}))Logger.call.warning('call警告',extra=CallLogExtra(type=CallType.EXTERN,params={'input':'value1'},resp={'output':'value2'}))# cron 日志适用于 xxl-jobLogger.cron.error('cron错误',extra=CronLogExtra(job_group='group',job_code='code'))# middleware 日志分为 MYSQL 、 MONGO 、 REDIS 、 ESLogger.middleware.debug('middleware调试',extra=MiddlewareLogExtra(type=MiddlewareType.REDIS,host='x.x.x.x'))# mq 日志分为 mq 、 mqtt 、 kafka , handle 分为 send 、 listenLogger.middleware.info('',extra=MqLogExtra(type=MqType.KAFKA,handle_type=MqHandleType.LISTEN))Logger.middleware.info('',extra=MqLogExtra(type=MqType.MQ,handle_type=MqHandleType.SEND))
Package: jiushu_logger_flask
jiushu-logger-flask【九书 Flask 路由专用】简介JF 专用格式化 logger 的 Flask 路由特供版，专门输出请求日志。使用方法importorjsonfromflaskimportFlask,gfromjiushu_logger_flaskimportRouteLoggingapp=Flask(__name__)# Logging for routes.# You can set which route should be skipped,#   or which pattern the route matches should be skipped.RouteLogging(app,skip_routes=['/api/health'],skip_regexes=[r'''^.*skip.*$'''])@app.get('/api/test')def_test():# You can get trace id of *this* request.# If apache-skywalking is used, this trace_id will be the ID tracing by skywalking.print(g.trace_id)returnb'Hello, world!',200@app.get('/api/health')def_health():returnorjson.dumps({'status':'UP'}),200,{'Content-Type':'application/json'}app.run('0.0.0.0',8080)
Package: jiushu_logger_starlette
jiushu-logger-starlette【九书 Starlette / FastAPI 路由专用】简介JF 专用格式化 logger 的 Starlette / FastAPI 路由特供版，专门输出请求日志。使用方法fromasyncioimportsleepfromstarlette.applicationsimportStarlettefromstarlette.middlewareimportMiddlewarefromstarlette.requestsimportRequestfromstarlette.responsesimportPlainTextResponse,JSONResponsefromstarlette.routingimportRoute,Mountfromjiushu_logger_starlette.route_logging_middlewareimportRouterLoggingMiddlewareasyncdef_test(request:Request):# You can get trace id of *this* request.# If apache-skywalking is used, this trace_id will be the ID tracing by skywalking.returnPlainTextResponse(request.state.trace_id.encode('utf_8'))asyncdef_test2(request:Request):awaitsleep(1.23456)returnJSONResponse({'result':True},headers={'Content-Type':'application/json'})asyncdef_should_be_skip(request:Request):returnPlainTextResponse(b'Hello, world!')asyncdef_health(request:Request):returnJSONResponse({'status':'UP'},headers={'Content-Type':'application/json'})routes=[Mount('/api',routes=[Route('/test',_test),Route('/test2',_test2,methods=['GET','POST']),Route('/should-be-skip',_should_be_skip),Route('/health',_health),])]middleware=[# Logging for routes.# You can set which route should be skipped,#   or which pattern the route matches should be skipped.Middleware(RouterLoggingMiddleware,skip_routes=['/api/health'],skip_regexes=[r'''^.*skip.*$'''])]app=Starlette(routes=routes,middleware=middleware)
Package: jivago
Jivago Framework - The Highly-Reflective Object-Oriented Python Web FrameworkJivago is an object-oriented, highly-reflective Python framework for building web applications. It relies heavily on type annotations and decorators to enforce typing, providing package auto-discovery and dependency injection out of the box. This leads to less boilerplate code, while maintaining loose-coupling across components.Also includes other Java-esque goodies, such as stream operations!Find the documentation over atdocs.jivago.io.Minimal Jivago Applicationfromjivago.jivago_applicationimportJivagoApplicationfromjivago.wsgi.annotationsimportResourcefromjivago.wsgi.methodsimportGET@Resource("/")classHelloResource(object):@GETdefget_hello(self)->str:return"Hello World!"app=JivagoApplication()if__name__=='__main__':app.run_dev()InstallationRequires Python3.6 or greater.pipinstalljivago
Package: jivago-streams
Jivago-StreamsJivago-Streams brings the ability to chain functional-style operations on collections.
This package provides a single class (Stream), which is extracted from the Jivago web framework.
Note thatjivago-streamscan be used independently from the Jivago web framework.fromjivago_streamsimportStream# Result : [4, 16, 36]square_of_even_numbers=Stream([1,2,3,4,5,6])\.filter(lambdax:x%2==0)\.map(lambdax:x**2)\.toList()Installationpip install jivago-streamsDocumentationThe documentation is available athttps://docs.jivago.io.
Package: jiwer
JiWERJiWER is a simple and fast python package to evaluate an automatic speech recognition system.
It supports the following measures:word error rate (WER)match error rate (MER)word information lost (WIL)word information preserved (WIP)character error rate (CER)These measures are computed with the use of the minimum-edit distance between one or more reference and hypothesis sentences.
The minimum-edit distance is calculated usingRapidFuzz, which uses C++ under the hood, and is therefore faster than a pure python implementation.DocumentationFor further info, see the documentation atjitsi.github.io/jiwer.InstallationYou should be able to install this package usingpoetry:$ poetry add jiwerOr, if you prefer old-fashioned pip and you're using Python >=3.7:$pipinstalljiwerUsageThe most simple use-case is computing the word error rate between two strings:fromjiwerimportwerreference="hello world"hypothesis="hello duck"error=wer(reference,hypothesis)LicenceThe jiwer package is released under theApache License, Version 2.0licence by8x8.For further information, seeLICENCE.ReferenceFor a comparison between WER, MER and WIL, see:Morris, Andrew & Maier, Viktoria & Green, Phil. (2004).From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.
Package: jixer-sync
Jixer - sync IP Search EngineA Python library for seamless querying of Shodan, Netlas, Zoomeye, and Fofa IP search engines. Simplify IP address information retrieval and integrate easily into applications.InstallationInstall the IP Search Engine library usingpip:pipinstalljixer_syncUsagefromjixer_syncimportBaseEngine,ShodanEngine,NetlasEngine# Example usage of BaseEnginewithBaseEngine(api_key='your_api_key')asengine:results=engine.fetch_ip_str(query='your_search_query')print(results)# Example usage of ShodanEnginewithShodanEngine(api_key='your_shodan_api_key')asengine:results=engine.fetch_ip_str(query='your_search_query')print(results)# Example usage of NetlasEnginewithNetlasEngine(api_key='your_netlas_api_key')asengine:results=engine.fetch_ip_str(query='your_search_query')print(results)For detailed information on configuration and supported engines, refer to the documentation.ConfigurationThe library provides configuration options for each supported engine. Set up API keys, customize search queries, and adjust parameters as needed.Supported EnginesShodanEngine: Queries Shodan IP search engine.NetlasEngine: Queries Netlas IP search engine.ZoomeyeEngine: Queries Zoomeye IP search engine.FofaEngine: Queries Fofa IP search engine.CreditsThis library relies on theRequestslibrary for making HTTP requests.LicenseThis project is licensed under theMIT License.IssuesReport issues or suggestions on theGitHub repository.ChangelogVersion 1.0.0(2023-11-22): Initial release.AcknowledgmentsSpecial thanks to the developers of Shodan, Netlas, Zoomeye, and Fofa for providing access to their IP search services.ContactFor support or collaboration, contact via email atssb000ss@gmail.com.
Package: jj
jjJJ is a remote HTTP mock library that simulates HTTP responses for incoming requests. It enables users to define conditions for incoming HTTP requests and specify the responses that should be returned. The library operates on a client-server architecture, allowing for the server to be run locally or deployed remotely, catering to diverse testing environments.FeaturesFlexible Request Matching: Define complex conditions to match incoming HTTP requests.Customizable Responses: Tailor responses to suit your testing needs.Client-Server Architecture: Run your mock server locally or deploy it remotely.Real-time Interaction: Modify mocking behavior on-the-fly without server restarts.DocumentationFor comprehensive guidance on utilizing JJ, including installation, setup, and usage instructions, visit thedocumentation page.
Package: jj2c
version number: 0.2.1 author: Tom TangOverviewJinja2 compilerInstallation / UsageTo install use pip:$ pip install jj2cTo use it:Render from folder to folder:jj2c template_folder/-V'a: AAA' 'b: BBB'-ooutput_folder/Render from zip to folder:jj2c template.zip-V'a: AAA' 'b: BBB'-ooutput_folder/Render from zip to zip:jj2c template.zip-V'a: AAA' 'b: BBB'-otemplate.zipRender to stdout:jj2ctemplate-file-V'a: AAA' 'b: BBB'Or clone the repo:$ git clone https://github.com/tly1980/jj2c.git
$ python setup.py installUsing Jinja2 extendsionsLet say you have ause_do.tplwith following contents:{%- set a = [] -%}
{%- do a.append(1) -%}
{%- do a.append(2) -%}
{%- do a.append(name) -%}
{{ a }}In order to render those content properly you will needjinja2.ext.doextension.Use-eor--extensionstags to specify the extensions. And you
can specify more than one.jj2c tests/fixtures/use_do.tpl -V 'name: jack' -e jinja2.ext.do jinja2.ext.i18nOutput is:Using extensions: ['jinja2.ext.do', 'jinja2.ext.i18n']
Compiling... file to stdout
src: tests/fixtures/use_do.tpl
dest:-
[1, 2, 'jack']ContributingTBDExampleTBD
Package: jjaljup
짤줍====트위터 관심글에 있는 그림 파일들을 내 컴퓨터에 다운로드합니다.Azyu님의 [FavoImgs](https://github.com/azyu/FavoImgs/)를 보고 리눅스나 맥에서도 돌아가면좋을 것 같아 만들었습니다.설치----짤줍은 [Python](https://www.python.org/download/) 2.6, 2.7 버전에서 돌아갑니다.짤줍의 설치는 다음과 같이 [pip](http://pip.readthedocs.org/en/latest/installing.html)를사용하는 것을 권장합니다.$ pip install jjaljup설치가 완료되면 `jjaljup` (Windows의 경우 `jjaljup.exe`)을 커맨드 라인에 입력하면 실행할 수있습니다.$ jjaljupUsage: jjaljup [OPTIONS] COMMAND [ARGS]......### Windows에서 설치Windows에서 [lxml](http://lxml.de)의 설치가 실패하는 경우,[Unofficial Windows Binaries for Python Extension Packages](http://www.lfd.uci.edu/~gohlke/pythonlibs/#lxml)에서비공식 인스톨러를 다운로드한 뒤 설치하면 해결할 수 있습니다. 32/64비트와 Python 버전 (2.6 또는2.7)을 잘 보고 받으세요.사용방법--------짤줍을 사용하려면 트위터 어플리케이션 등록을 해야합니다.[Twitter Application Management](https://apps.twitter.com/)에 가서"Create New App" 버튼을 눌러 새로운 앱을 만드세요. 이름, 설명, 웹사이트 주소는 아무렇게나 해도됩니다. 앱을 만든 뒤 "API Keys" 탭으로 가면 API key와 API secret이 있습니다. 커맨드가 실행될때 이 두 값이 각각 `JJALJUP_API_KEY`와 `JJALJUP_API_SECRET` 환경 변수에 들어가있어야 합니다. 다음은 현재 터미널에서 임시로 환경 변수를 설정한 뒤 짤줍을 실행하는 예시입니다. 여러분들이가진 값과는 다를 수 있습니다.$ export JJALJUP_API_KEY=bOJZcMNBCdfIZfw70DAd4BCBP$ export JJALJUP_API_SECRET=YvMMkcKo9vFhlX02wd9TKuPAdiPNAs7eDlFZmkV2e2SeXSo7qc$ jjaljup syncWindows에서는 `export` 대신 `set`을 사용하면 됩니다.`JJALJUP_DATABASE_URI` 환경 변수를 설정하면 데이터베이스를 지정할 수 있습니다. 기본값은`sqlite:///jjaljup.db`로, 현재 경로에 `jjaljup.db`라는 SQLite 파일을 만듭니다.자세한 내용은 [SQLAlchemy 문서](http://docs.sqlalchemy.org/en/rel_0_9/core/engines.html#database-urls)를참조하세요.환경 변수를 영구적으로 저장하려면 Linux/Mac에서는 홈 디렉토리의 `.profile` 파일을 사용하거나Windows에서는 시스템 속성 - 고급 - 환경 변수에서 설정하면 됩니다.`jjaljup sync`를 실행하면 선택된 계정의 모든 관심글에 있는 그림 파일을 다운로드 합니다.짤줍은 다음과 같은 종류의 파일들을 다운로드할 수 있습니다.* 트위터에서 직접 올린 그림* 트위터에서 직접 올린 움직이는 GIF (MP4 동영상 파일로 받아짐)* 외부 링크 중 그림 파일 확장자로 끝나는 경우 (JPG, JPEG, GIF, PNG)* Twitpic, yfrog에 올린 그림`jjaljup watch`를 실행하면 커맨드가 실행되는 동안 선택된 계정의 활동을 실시간으로 감시하면서관심글을 담을 때마다 그림 파일을 다운로드합니다.보다 자세한 설명은 커맨드를 입력한 후 `--help`를 덧붙이면 볼 수 있습니다 (간단한 영어).$ jjaljup sync --helpUsage: jjaljup sync [OPTIONS]...주의사항--------계정으로 앱 인증을 하면 접속 토큰이 데이터베이스에 평문으로 저장됩니다. 여러분이 만든 트위터 앱의 APIkey와 API secret이 있어야 접속 토큰을 사용할 수 있기 때문에 아주 큰 문제는 아니지만, 그래도데이터베이스 파일이 유출되지 않도록 주의해 주세요. 만약 유출될 경우 앱 관리 페이지에서 "RegenerateAPI keys" 버튼을 눌러 키를 재생성하면 피해를 막을 수 있습니다.나중에 추가될 수도 있는 기능----------------------------* 서드 파티 이미지/비디오 사이트 추가 지원: imgur, Vine 등.* 리스트, 커스텀 타임라인 지원. 단, 커스텀 타임라인은 아직 공식 API가 없음 (베타 상태).* 다른 사람의 관심글 저장하기.
Package: jjb-puppetlabs
Jenkins Job Builder takes simple descriptions ofJenkinsjobs inYAMLformat,
and uses them to configure Jenkins. You can keep your job descriptions in human
readable text format in a version control system to make changes and auditing
easier. It also has a flexible template system, so creating many similarly
configured jobs is easy.To install:$ sudo python setup.py installOnline documentation:http://docs.openstack.org/infra/jenkins-job-builder/DevelopersBug report:https://storyboard.openstack.org/#!/project/723Repository:https://git.openstack.org/cgit/openstack-infra/jenkins-job-builderCloning:git clone https://git.openstack.org/openstack-infra/jenkins-job-builderPatches are submitted via Gerrit at:https://review.openstack.org/Please do not submit GitHub pull requests, they will be automatically closed.More details on how you can contribute is available on our wiki at:http://docs.openstack.org/infra/manual/developers.htmlWriting a patchWe ask that all code submissions bepep8andpyflakesclean.  The
easiest way to do that is to runtoxbefore submitting code for
review in Gerrit.  It will runpep8andpyflakesin the same
manner as the automated test suite that will run on proposed
patchsets.When creating new YAML components, please observe the following style
conventions:All YAML identifiers (including component names and arguments)
should be lower-case and multiple word identifiers should use
hyphens.  E.g., “build-trigger”.The Python functions that implement components should have the same
name as the YAML keyword, but should use underscores instead of
hyphens. E.g., “build_trigger”.This consistency will help users avoid simple mistakes when writing
YAML, as well as developers when matching YAML components to Python
implementation.Installing without setup.pyFor YAML support, you will needlibyamlinstalled.Mac OS X:$ brew install libyamlThen install the required python packages usingpip:$ sudo pip install PyYAML python-jenkins
Package: jjc-card-game
JJC's Card GameThis is a simple card played over a series of round. Each round, players draw one card. The player with the highest card received 2 points. Players with penalty cards lose a point. First player to 21 points wins.InstallationMake sure you have python 3.6 or higher installed, then:pipinstalljjc-card-gamePlayjjc-card-gameThen follow the on-screen rules and instructions.Or try these more advanced options:jjc-card-game -d Jonathan Nicholas Austinto play a game with these three players. The-dspeeds up gameplay by dealing all the cards at once.jjc-card-game --helpto see even more optionsDevelopmentDevelopment tools: Windows 10, PowerShell, and PyCharm.gitclonehttps://github.com/jonathanchukinas/card_game.gitcdcard_gamepipinstallflit# for build, packagingpython-mvenv.venv# create virtual environment.venv\scripts\activate# activate virtual environmentflitinstall--pth-file# set up editable install# modify source codejjc-card-game# run modified app# repeatdeactivate# exit virtual environmentRunning the testsTest are written forpytestand automated bytox.
Game logic has 95% test coverage, while
the command-line interface / ouput has less than 50%.To run all the tests:pipinstalltox,pytestcdpath\to\project\directorytoxTests will be run against all these python versions, if you have them:v3.6v3.7v3.8For a faster way to run tests:pytestBuilt Withpythonand python packages:clickfor created command line interfacePTablefor generating pretty scorecard tablesAuthorsJonathan Chukinas-initial releaseLicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for detailsAcknowledgementsBrian Okkenfor hisTest & Codepodcast andPython Testing with pytestbook, which jump-started my testing knowledge early in 2019 and recently helped me integrate pytest, flit, and tox together.Luciano Ramalhofor his outstandingFluent Python, which taught me much of what I know about python under the hood, dunder methods, lru cache, and so much more.
Package: jjckdockertool
Copyright (c) 2005-2020, NumPy Developers.
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:* Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above
   copyright notice, this list of conditions and the following
   disclaimer in the documentation and/or other materials provided
   with the distribution.

* Neither the name of the NumPy Developers nor the names of any
   contributors may be used to endorse or promote products derived
   from this software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Package: jjcli
Namejjcli - python module for command-line filterSynopsisas ascript:jjcli skel     ## a initial filter skeleton
jjcli          ## manualas a module:from jjcli import *       ## re.* functions also imported
cl=clfilter(opt="do:", doc=__doc__) 
                          ## options in cl.opt  (...if "-d" in cl.opt:)
                          ##    autostrip         (def=True)
                          ##    inplace           (def=False) 
                          ##    fs (for csvrow()) (def=",")
                          ##    doc=__doc__     (for --help)
                          ##    longopts=["op1",...]

for line in cl.input():...    ## process one rstriped line at the time
for txt in cl.text():...      ## process one striped text at the time
    ## process txt            ##   (end of line spaces and \\r also removed)
for par in cl.paragraph():... ## process one striped paragraph at the time
for tup in cl.csvrow():...    ## process one csv row at the time
for tup in cl.tsvrow():...    ## process one tsv row at the time

cl.lineno()         ## line number
cl.filelineno()
cl.parno()          ## paragraph number
cl.fileparno()
cl.filename()       ## filename or "<stdin>"
cl.nextfile()
cl.isfirstline()
cl.args  cl.opt     ## command line arguments and options (after clfilter())Descriptionjjcliis a opinioned Python module that tries to simplify the creation ofunixfilters. It is based on:getopt  (for command line options and args)fileinput (for [files/stdin] arguments)re (regular expressions should be native)glob (glob.glob should be native)csv  (for csv and tsv inputs)urllib.request (to deal with input argumens that are url)subprocessRegular expressionsWe want to have all re.* functions available (as if they were native
functions).In order to enablereflags, use: re.I re.X re.SSubprocesses   (qx, qxlines, qxsystem)a=qx( "ls" )
for x in qxlines("find | grep '\.jpg$'"): 
  ...
qxsystem("vim myfile")Execute command return its stdoutqx(*x)      →  returns    subprocess.getoutput(x)Execute command return its stdout linesqxlines(*x) →  returns    subprocess.getoutput(x).splitlines()Execute command -- systemqxsystem(*x) →  calls     subprocess.call(x,shell=True)STDERR - warn, diewarn(*args)  → print to stderr
die(*args)   → warn and exit 1Other functionsslurpurlutf8(self,f)

filename    = lambda s : F.filename()      # inherited from fileinput
lineno      = lambda s : F.lineno()
filelineno  = lambda s : F.filelineno()
parno       = lambda s : s.parno_          # paragraph number
fileparno   = lambda s : s.fileparno_
nextfile    = lambda s : F.nextfile()
isfirstline = lambda s : F.isfirstline()
isfirstpar  = lambda s : s.fileparno == 1
close       = lambda s : F.close()
Package: jj-district42
jj-district42Installationpip3installjj-district42Usageimportjjimporthttpxfromjj.mockimportmockedfromjj_district42importHistorySchemafromvaleraimportvalidate_or_failmatcher=jj.match("GET","/users")response=jj.Response(status=200,json=[])withmocked(matcher,response)asmock:resp=httpx.get("http://localhost:8080/users",params={"user_id":1})assertvalidate_or_fail(HistorySchema%[{"request":{"method":"GET","path":"/users","params":{"user_id":"1"},}}],mock.history)More examples are availablehere
Package: jjgimmethis
A package to randomly generate names, usernames, passwords and things/objects.Features:1. Generate name based on user’s options.
- First name only
- First name and last name
- First name, middle name and last name2. Generate username based on user’s options.
- Words
- Underscore
- Number
Example format of the generated username: smart_Potato253. Generate password based on user’s options.
- Lowercase letters
- Uppercase letters
- Numbers
- Symbols and special characters4. Generate random different things.
Example: book, chair, car etc.Change Log0.0.1 (30/04/2022)First ReleaseContains 4 functions that generates name, username, password, and random things.
Package: jjinline_files
Inline FilesThis Python package to allowinline files-- files inside the program.An inline file is a file stored within another file. This parent file can be any kind of file, but a .py file is preferred due to how an inline file is defined.Synopsisfrom jjinline_files import *
print(message, message2)

"""ILF
==> message
Hello World!

==> message2
And this is all for now.
"""DefinitionWe use the following syntax to define an inline file:r"""ILF
==> ID1
Hello World!

==> ID2:json
{
    "hello": "world"
}
"""Inline files are defined inside a multiline comment or docstring.
Each "file" starts with==> IDor==> ID:type, whereIDis the
inline file's name.
In the example above, there are two inline files, "ID1" and "ID2".
ID2 has a typejson.If a "file" has an explicit type, the "file" will be
processed accordingly. For example, a JSON file will be processed
using thejsonmodule importer. Default type is text file.
Currently, the module supports the following types:text files (default)   -- a (multiline) stringjson  -- anyyaml  -- anyjj2   -- jinja2 template -- defines a function(dict, **args)f   -- a f-string -- defines a function(dict, **args)csv, tsv  -- list(list(str))lines -- list(str)File types and their importersyaml and jsontypical uses: configuration files, knowledge representationperform yaml-parse(text);return a python value (list, dict, etc)r"""ILF
from jjinline_files import *

print(f["filename"])

==> f:json
{
    "filename": "calendar",
    "extension": "json"
}

==> g:yaml
filename: file1
extension: yaml
"""linesperform text.splitlines()return a list of stringscsv and tsvperforms csv-parse(txt)return a list(list(strings))templates : f (fstrings) and jinja2return a function. Parameter:(d:dict or **args) → stringfrom jjinline_files import *
print( ppname(name="James Bont") )

"""ILF
==> ppname:f
surname {name.split()[-1]}  fullname {name}

"""