Saravanan666/pypi-org huggingface dataset:
Package: jennifer
JENNIFER 5, JenniferSoft APM Python agent제니퍼란?
제니퍼는 Python 환경에서 운영 중인 시스템을 실시간 모니터링(Monitoring) 할 수 있는 APM 프로그램입니다.
Python 환경에서의 모든 트랜잭션과 인프라 전반에서 대한 정확하고 심층적인 상세 정보를 통해 운영 중인 시스템을 최소한의 부하로 모니터링 해 보세요.제니퍼 Python agent 설치방법제니퍼 에이전트를 일반적으로 설치하는 방법을 설명한다. PyPI(pip)를 통해서
설치한다.지원 범위OS: Linux 배포판과 macOS를 지원한다Python: CPython의 2.x버전은 2.7 이상, 3.x 버전은 3.3 이상을
지원한다.Web framework 지원 범위Flask >= v0.11django >= v1.5DB driverMySQL or MariaDBmysqlclientpymysqlsqlite3sqlite3설치 방법pip를 통해서 jennifer를 설치한다.$pipinstalljennifer설정 방법설치하고 나면jennifer-admin이라는 커멘드가 설치된다.
제니퍼 에이전트를 시작하기에 앞서서 JENNIFER의 data server와 연결시에
필요한 설정들을 마쳐야 한다. 설정 템플릿은 명령어를 통해서 가능하다.$jennifer-admingenerate-config해당 명령어를 실행하면jennifer.ini파일이 생성된다. 생성된
파일의 각 필드에 대해서 설명하면필드설명server_addressdata server의 IPserver_portdata server의 portdomain_id도메인 ID, 테스트를 신청하면
제니퍼에서 제공한다.inst_id인스턴스의 아이디log_pathlog 파일의 경로inst_id의 설정방법 인스턴스의 ID는 Data server가 agent를
식별하기 위한 값이다. Data server가 유니크하게 할당할 수 있기 때문에
-1로 적어두면 Data server가 할당한 값을 사용할 수 있다. 수동으로
설정도 가능하지만, 권장하지 않는다.실행 위 과정에서 생성한 설정파일을 가지고 이제 JENNIFER를 실행할 수
있다.$JENNIFER_CONFIG_FILE=<설정파일경로>jennifer-adminrun<python실행코드><설정파일 경로>는 위에서 생성한 설정파일의 경로를 의미한다.<python 실행  코드>는 기존에 파이썬 웹 애플리케이션 서버를
실행하던 커맨드(예: python manage.py runserver, uwsgi -i uwsgi.ini,
…)를 의미한다.예를들어,sh  $ JENNIFER_CONFIG_FILE=jennifer.inijennifer-adminrun uwsgi-iuwsgi.ini위와 같이 실행할 수 있다.License© Copyright 2018 JenniferSoft, All right reserved.
Package: jennifer-python
JENNIFER 5, JenniferSoft APM Python agentjennifer-python이란?jennifer-python은 Python 환경에서 운영 중인 시스템을 실시간 모니터링(Monitoring) 할 수 있는 APM 프로그램입니다.
Python 환경에서의 모든 트랜잭션과 인프라 전반에 대한 정확하고 심층적인 상세 정보를 통해 운영 중인 시스템을 최소한의 부하로 모니터링해 보세요.제니퍼 Python agent 설치 방법JENNIFER Python 에이전트는 공개된 PyPI(pip)를 통해서 설치한다.지원 범위OS: Linux 배포판과 macOS를 지원한다Python: CPython의 2.x 버전은 2.7 이상, 3.x 버전은 3.3 이상을 지원한다.Web framework 지원 범위Flask >= v0.11django >= v1.5fastapi >= v0.78.0DB driverMySQL or MariaDBmysqlclient >= 2.0.3pymysql >= 1.0.2sqlite3sqlite3PostgreSQLpsycopg2 >= 2.8psycopg2-binary >= 2.8Oraclecx-Oracle >= 8.0.0mongodbpymongo >= 3.10.1redisredis >= 4.0.2pyodbcpyodbc >= 4.0.39설치 방법pip를 통해서 jennifer-python을 설치한다.$pipinstalljennifer-python설정 방법위의 명령어를 수행하면jennifer-admin이라는 도구가 함께 설치된다.
그리고 이 명령어를 통해 jennifer-python 모듈이 제니퍼 데이터 서버로 연결을 하기 위해
필요한 정보를 담은 설정 파일을 만들 수 있다.$jennifer-admingenerate-config해당 명령어를 실행하면jennifer.ini파일이 생성된다. 생성된
파일의 각 필드는 다음의 의미를 갖는다.FieldDescriptionserver_addressdata server의 IPserver_portdata server의 portdomain_id도메인 ID, 테스트를 신청하면
제니퍼에서 제공한다.inst_id인스턴스의 아이디inst_id의 설정 방법인스턴스 ID는 Data server가 agent를 식별하기 uint16 범위의 숫자 값이다.
만약 이 값을 -1로 설정하면 Data server 측에서 자동으로 생성한 고유 ID를 할당한다.실행위 과정에서 생성한 설정 파일을 가지고 이제 JENNIFER를 실행할 수 있다.$JENNIFER_CONFIG_FILE=<설정파일경로>jennifer-adminrun<python실행코드>$JENNIFER_CONFIG_FILE=<설정파일경로>jennifer-adminrunasync<python실행코드><설정 파일 경로>는 위에서 생성한 설정 파일의 경로를 의미한다.<python 실행 코드>는 기존에 파이썬 웹 애플리케이션 서버를 실행하던 커맨드(예: python manage.py runserver, uwsgi -i uwsgi.ini,
…)를 의미한다.예를 들어, jennifer.ini 파일이 /home/user/jennifer 디렉터리에 위치하고, 기존에 파이썬 응용 프로그램을 “uwsgi -i uwsgi.ini”로 실행했다면 다음과 같이 실행한다.$JENNIFER_CONFIG_FILE=/home/user/jennifer/jennifer.inijennifer-adminrunuwsgi-iuwsgi.ini반면, uvicorn과 같은 비동기 기반의 호스팅 환경이라면 “runasync” 옵션을 이용해 다음과 같이 실행한다.$JENNIFER_CONFIG_FILE=/home/user/jennifer/jennifer.inijennifer-adminrunasyncuvicorn--loopasynciomain:app유의 사항일부 웹 애플리케이션 서버의 경우 jennifer-python의 적절한 데이터 수집을 위해 옵션을 아래와 같은 옵션을 추가해야 한다.호스팅 서버옵션uwsgi–enable-threadsuwsgi의 경우 jennifer-python의 적절한 데이터 수집을 위해 “–enable-threads” 옵션을 추가해야 한다.License© Copyright 2022 JenniferSoft, All right reserved.
Package: jensen-shannon-centroid
Jensen-Shannon CentroidA lightweight python package to calculate the Jensen-Shannon Centroid of a set of categorical distributions. The Jensen-Shannon Centroid is the minimizer Q of the equation:$$\mathcal{L}(Q) = \sum_{m} \text{JS}(Q\|p_{m})$$where JS is the Jensen-Shannon divergence. We follow the ConCave–Convex procedure (CCCP) from Nielsen, 2020 to find Q.Nielsen, Frank. 2020. "On a Generalization of the Jensen–Shannon Divergence and the Jensen–Shannon Centroid" Entropy 22, no. 2: 221.https://doi.org/10.3390/e22020221InstallationInstall directly using pip:$ pip install jensen-shannon-centroidDependenciesnumpyUsageThere is one main method,jensen_shannon_centroid.calculate_jsc. This method takes in a list of size $M\times N\times K$ where:$K$ is the number of classes in each distribution$N$ is a set of different distributions each having $K$ classes$M$ are the different views of each distribution for which the Jensen-Shannon centroid will be calculatedThe method will return an array of size $N\times K$, which are the Jensen-Shannon centroids of the set of $M$ different views of each of the $N$ distributions.Here is an example usage:fromjensen_shannon_centroidimportcalculate_jscdistributions=[[[0.1,0.9],[0.2,0.8]],[[0.15,0.85],[0.5,0.5]]]calculate_jsc(distributions)>>>returns:array([[0.12391947,0.87608053],[0.34213098,0.65786902]])
Package: jenti
Patch and MergeCan create patches from both 2D or 3D imagesCan merge 2D or 3D patchesAs for 3D, the primary focus is 3D CT data. The data should be converted to an array before making 3D patches.So, the 2D image or 3D volume is needed to convert to an array first.How to installpip install jenti==0.0.4pip install jentiHow to useSample demonstration on how to use this code is given intest.pyandtest.ipynb.How to importfromjentiimportpatchCreate patches from a 2D image# Read imageim=Image.open('c.jpg')# color imageim.show()image=np.array(im)# convert to array# Create patchespatch_shape=[100,100]overlap=[10,10]# overlap between two adjacent patches along both axespatch=Patch(patch_shape,overlap,patch_name='patch2d',csv_output=True)patches,info,org_shape=patch.patch2d(image)# Save patchespatch.save2d(patches,save_dir='./save2d',ext='.png')If thecsv_outputis set toTrue, then it will save the locations of each patchin the original image in acsvfile.Patch names will be like:xxxx0000,xxxx0001,xxxx0002, and so on.Create patches from a 3D volume# Read volumedata=sio.loadmat('volume.mat')data=data['data']# shape: 128 x 128 x 50  x 1# Create patchespatch_shape=[32,32,16,1]# H x W x D x Choverlap=[8,8,8,0]patch=Patch(patch_shape,overlap,patch_name='patch3d',csv_output=True)patches,info,org_shape=patch.patch3d(data)# Save patchespatch.save3d(patches,save_dir='./save3d',ext='.mat')Merge 2D patchesMerging can be done in two ways.Method 1: Read all the patch files first, then merge them together.# Merge patchesnames=os.listdir('./save2d')patches=[]info=pd.read_csv('patch2d.csv')info=np.array(info)org_shape=(3024,4032,3)fornameinnames:p=Image.open(os.path.join('./save2d',name))p=np.array(p)patches.append(p)merge=Merge(info,org_shape,dtype='uint8')merged=merge.merge2d(patches)merged_im=Image.fromarray(merged)merged_im.show()merged_im.save('merged2d.png')Method 2: Provide only the patch directory.merge=Merge(info,org_shape,dtype='uint8')merged=merge.merge_from_dir2d('./save2d')merged_im=Image.fromarray(merged)merged_im.show()merged_im.save('merged2d.png')Merge 3D patchesMethod 1: Read all the patch files first, then merge them together.# Merge patchesnames=os.listdir('./save3d')patches=[]info=pd.read_csv('patch3d.csv')info=np.array(info)org_shape=(128,128,50,1)fornameinnames:p=sio.loadmat(os.path.join('./save3d',name))p=p['p']patches.append(p)merge=Merge(info,org_shape,dtype='float32')merged=merge.merge3d(patches)sio.savemat('merged3d.mat',{'m':merged},do_compression=True)Method 2: Provide only the patch directory.merge=Merge(info,org_shape,dtype='float32')merged=merge.merge_from_dir3d('./save3d')sio.savemat('merged3d.mat',{'m':merged},do_compression=True)
Package: jentry
jentryA simple tools to get the entries of a java projects, based onjavalanglibrary.InstallationYou can simply install it withpipcommand line from the official PyPI site.pip install jentryFor more information about installation, you can refer to theinstallation guide.Quick StartUse with CLIYou can directly usejentryCLI to get the entry of a java project. Such as the command belowjentrydemoThe output should be like as shown follow (in this project, we have 2 different entries)Main
homework.MainOnly Use One EntryYou can get exactly one entry with-Fcommandjentry-FdemoThe output should beMainThis command can be used when you are trying to run a compiled java project, like thisjava-cptarget:${CLASSPATH}$(jentry-Fdemo)The entry it found will be applied into thejavacommand line.Pretty Print EntryActually, these entries can be printed with prettier ways, such as json and table.jentry-fjsondemoThe json-formatted output.[{"entrance":"Main","package":null,"class":"Main","file":"demo/2018_spring_16061104_10/src/Main.java"},{"entrance":"homework.Main","package":"homework","class":"Main","file":"demo/oo_course_2019_17373331_homework_2/src/homework/Main.java"}]And if the-foption is assigned totablejentry-ftabledemoA table with all the entries will be placed together.+---------------+----------+-------+----------------------------------------------------------------+
|     Entry     | Package  | Class |                            Filename                            |
+---------------+----------+-------+----------------------------------------------------------------+
|      Main     |  <none>  |  Main |           demo/2018_spring_16061104_10/src/Main.java           |
| homework.Main | homework |  Main | demo/oo_course_2019_17373331_homework_2/src/homework/Main.java |
+---------------+----------+-------+----------------------------------------------------------------+OthersOther features can be found in the help information, which can be displayed with-hoption.jentry-hUsage: jentry [OPTIONS] [SOURCES]...

  Jentry - find the entry of your java project.

Options:
  -v, --version                   Show package's version information.
  -f, --format [table|json|entry]
                                  The format to display the entries  [default:
                                  entry]
  -s, --sorted_by [file|package|class|entry]
                                  The order to sorted by.  [default: file]
  -r, --reverse                   Reverse the sorted result, only applied when
                                  -s is used.  [default: False]
  -F, --first_only                Only show the first entry.  [default: False]
  -h, --help                      Show this message and exit.Use with Pythonjentrycan be imported into pythonfromjentry.entry.scriptimportload_entries_from_projectif__name__=='__main__':forentryinload_entries_from_project('demo'):print(repr(entry))The output should be<JavaEntry class: Main, filename: 'demo/2018_spring_16061104_10/src/Main.java'>
<JavaEntry class: homework.Main, filename: 'demo/oo_course_2019_17373331_homework_2/src/homework/Main.java'>Licensejentryreleased under the Apache 2.0 license.
Package: jenviz
jenvizis a command line tool to visualize your Jenkins
job relationships.InstallationInto avirtualenv:virtualenv venv
source venv/bin/activate
pip install -e .
# now you can use the tool
jenviz -hConfigurationThere are currently 2 ways to configurejenviz.adding the Jenkinsurl,usernameandpasswordvia command line parameters:$ jenviz --jenkins-url https://my-jenkins-instance/ --jenkins-user joe --jenkins-password 123 SomeJobNameusing a.inistyle configuration file and profiles:$ cat ~/.config/jenviz.ini
[profile1]
url=https://my-jenkins-instance
user=joe
password=123

$ jenviz -p profile1 SomeJobNameContributionsPlease use github (https://github.com/toabctl/jenviz) issues
and pull requests for discussions and contribution.FAQWhy are subprojects are not visible in the output?Try to update the Parameterized Trigger Plugin on the jenkins instance.
Package: jep
Jep - Java Embedded PythonJep embeds CPython in Java through JNI.Some benefits of embedding CPython in a JVM:Using the native Python interpreter may be much faster than
alternatives.Python is mature, well supported, and well documented.Access to high quality Python modules, both native CPython
extensions and Python-based.Compilers and assorted Python tools are as mature as the language.Python is an interpreted language, enabling scripting of established
Java code without requiring recompilation.Both Java and Python are cross platform, enabling deployment to
different operating systems.InstallationSimply runpip install jepor download the source and runpip install ..
Building and installing require the JDK, Python, and optionally numpy to be installed beforehand.DependenciesPython >= 3.6Java >= 1.8NumPy >= 1.7 (optional)Notable featuresInteractive Jep console much like Python’s interactive consoleSupports multiple, simultaneous, mostly sandboxed sub-interpreters or shared interpretersNumpy support for Java primitive arraysHelpDocumentationJavaDocMailing List (deprecated)Known Issues and HelpContribution GuidelinesProject PageWe welcome comments, contributions, bug reports, wiki documentation, etc.If you need help, please first search for existing solutions online, in the
the issues, and on the wiki. If you still need help, please open a GitHub issue
and we will try and help you. Please remember to close the issue once it has
been resolved.Jep Team
Package: jep-cmake
JEP-based CMake support in the making.This is a command line application implementing a JEP
backend for CMake. It enables editors that have JEP-plugin installed to
improve their CMake editing support beyong pure syntax highlighting.Current state and featuresParser for CMake files.Builds dictionary of user functions and macros.Code completion of commands (built-in and user functions and macros),
from local and (directly or indirectly) imported modules.Upcoming features and feature ideasCode completion for all files in a project, including parent CMake
files.Code completion for variables (respecting scope rules).Code completion for targets.Go to definition of commands, variables, targets.Error annotations.Renaming of user commands, variables, targets.Installationjep-cmakecan be installed in various ways. To run it requires an
installed Python interpreter, version 3.3 or greater.After installation, the used Python environment has a new commandjep-cmake, that will run the backend.From Source Code> git clone https://github.com/jep-project/jep-cmake.git
> cd jep-cmake
> pip install .From PyPI> pip install jep-cmakeUsageSee theJEP
protocolfor detailed instruction how to configure JEP via a.jepfile. In
the most simple situation (jep-cmakein path, …) the following.jepfile in the root folder of your project that contains CMake
files should be enough:*.cmake,CMakeLists.txt:
jep-cmakeSeejep-cmake-hfor available command line options:> jep-cmake -h
usage: jep-cmake-script.py [-h] [--version {2.8.12,3.4}] [--builtin-cmake]
                           [--builtin-ctest] [--builtin-deprecated]

JEP backend providing CMake editing support.

optional arguments:
  -h, --help            show this help message and exit
  --version {2.8.12,3.4}
                        CMake version to be supported, mainly used for
                        completion of built-in commands.
  --builtin-cmake       If specified, built-in CMake commands are part of code
                        completion.
  --builtin-ctest       If specified, built-in ctest commands are part of code
                        completion.
  --builtin-deprecated  If specified, built-in CMake commands that have been
                        deprecated are part of code completion.The various built-in options are available to finetune the backend’s
interaction with the editor being used. Some editors already support
code completion for built-in CMake commands. In that case it is more
efficient remove them from the backends completion options (by not
specifying the corresponding command line option).
Package: jepler-circuitpython-udecimal
IntroductionReduced version of the decimal library for CircuitPythonDependenciesThis library depends on:Adafruit CircuitPythonThe library also runs on desktop Python3, and should give numerically identical
results across all platorms.Installing from PyPITo install for current user:python3-mpipinstall--userjepler-circuitpython-udecimalTo install system-wide (this may be required in some cases):sudopython3-mpipinstalljepler-circuitpython-udecimalTo install in a virtual environment in your current project:mkdirproject-name&&cdproject-namepython3-mvenv.envsource.env/bin/activatepip3installjepler-circuitpython-udecimalUsage Example>>>fromjepler_udecimalimportDecimal>>>Decimal(2)/3Decimal('0.6666666666666666666666666667')>>>Decimal('.1')+Decimal('.2')==Decimal('.3')TrueContributingContributions are welcome! Please read ourCode of Conductbefore contributing to help this project stay welcoming.DocumentationFor information on building library documentation, please check outthis guide.
Package: jepop
jepop - pops Juniper Ethernet headers from a .pcap fileUsageusage: jepop [-h] [--overwrite] [--dmac DMAC] [--smac SMAC] [--vlans VLANS] inpcap outpcapPackets captured on wan interfaces contain hostpath packetsHostpath packets contain an additional Juniper Ethernet header which is not understood outside of Juniper productsThis limits the ability to use these .pcap files with tools such as tcpreplay, ngrep, tcpflow and moreThis utility reads packets from a .pcap file, pops the Juniper Ethernet header if found, then writes the packets to a new .pcapIt uses scapy (https://scapy.net) to achieve thisHostbound packets (input direction) may have L2 headers stripped by the PFE, in this case a crafted Ethernet header is addedBy default the crafted Ethernet header src and dst macs will be all zeros, you can specify macs with thesmacanddmacoptionsAdditionally, you can specify add up to 2 vlan tags to be added with thevlansoptionReads packets frominpcapinto a PacketListEach packet is checked for the presence of the Juniper Ethernet header-- If found, the l2_header_presence bit is used to determine if the payload is L2-- If L2, Juniper Ethernet header is popped and packet is appended to the output PacketList-- If not L2, the payload_type field is used to determine the L3 payload-- A new packet is created with a crafted Ethernet header, any vlans specified, and the L3 payload-- Packet is appended to output PacketListOutput PacketList is written tooutpcapOPTIONAL ARGUMENTSsmac- source mac to be added to crafted L2 headerdmac- destination mac to be added to crafted L2 headervlans- dot1q vlans to be added after crafted L2 headeroverwrite- allows output file to be overwrittenLICENSEGPL-2.0CONTRIBUTORSJuniper Networks is actively contributing to and maintaining this repoPlease contactjnpr-community-netdev@juniper.netfor any queriesContributors:Chris Jenn
Package: jep-python
This is the Python implementation of the Joint Editors Protocol (JEP),
seehttp://joint-editors.org/for more information. jep-python is providing
language authors with a frontend library for IDE/editor integration and
a backend library for language support.This implementation is currently compatible with Python 3.3+.Look at these associated projects for examples of productive use of the library:Frontend used in Sublime editor:https://github.com/jep-project/jep-sublimeBackend used for improved CMake language support:https://github.com/jep-project/jep-cmakeBackend supportImplementing JEP based support for a custom language is easy. Simply
derive one or more listener classes to respond to frontend messages and
then run the backend with those listeners.fromjep_py.backendimportBackend,FrontendListenerclassListener(FrontendListener):defon_completion_request(self,completion_request,context):# process completion request and send back response:completion_response=f(completion_request)context.send_message(completion_response)# instantiate and start backend service with our listeners:listener=Listener()backend=Backend([listener])backend.start()Callbacks that are not needed by a certain listener do not need to be
overridden in the derived class.While the user is editing a file in a connected IDE the frontend will
repeatedly sendContentSyncobjects to the backend. The backend
implementation already processes these messages internally and provides
an accumulated file view to client code. Since backend-internal message
processing is donebeforemessages are passed to subscribed listeners,
you can process the latest view of a file directly inside your
listener’s handler ofContentSyncby accessing the context’scontent_monitorfilepath dictionary:defon_content_sync(self,content_sync,context):# get the content monitor's view of the file that was just updated:file_content=context.content_monitor[content_sync.file]# ...Frontend supportSimilarly in an IDE frontend you again derive listener classes, this
time listening to backend messages. Since the frontend initiates the
connection you additionally have to create such a connection for a
certain language. JEP service lookup is then used to determine the
supporting backend and the frontend will start it in its own subprocess.Here is an example shutting down the backend service upon reception of
its first alive message:importdatetimefromjep_py.frontendimportFrontend,BackendListener,Statefromjep_py.schemaimportShutdownclassMyListener(BackendListener):defon_backend_alive(self,context):context.send_message(Shutdown())frontend=Frontend([MyListener()])connection=frontend.get_connection('localfile.mydsl')whileconnection.stateisnotState.Disconnected:connection.run(datetime.timedelta(seconds=0.1))
Package: jeraconv
jeraconvjeraconv (Japanese Era Name Converter) is a converter that converts Japanese eras to West calendar.Installation$ pip install jeraconvUsageJapanese calendar to West calendarfromjeraconvimportjeraconv# Create J2W class instancej2w=jeraconv.J2W()# ex.1 : General usageprint(j2w.convert('文治6年'))# result (int) 1190# ex.2 : Full-width numbers are also availableprint(j2w.convert('平成３１年'))# result (int) 2019# ex.3 : It is also possible to write "1年" as "元年"print(j2w.convert('令和元年'))# result (int) 2019# ex.4 : Returns a ValueError if the era name does not existprint(j2w.convert('牌孫4年'))# result ValueErrorWest calendar to Japanese calendar.fromjeraconvimportjeraconv# Create W2J class instancew2j=jeraconv.W2J()# ex.1 : General usageyear=2019month=5day=31print(w2j.convert(year,month,day))# result (str) 令和1年5月31日# ex.2 : When receiving a response in dictionary typeprint(w2j.convert(year,month,day,return_type='dict'))# result (dict) {'era': '令和', 'year': 1, 'month': 5, 'day': 31}# ex.3 : When receiving a response in list typeprint(w2j.convert(year,month,day,return_type='list'))# result (list) ['令和', 1, 5, 31]# ex.4 : When receiving a response in tuple typeprint(w2j.convert(year,month,day,return_type='tuple'))# result (tuple) ('令和', 1, 5, 31)# ex.5 : If the date is omitted, convert the execution dateprint(w2j.convert())
Package: jeremyrandompassword
Bloghttps://wangonya.com/blog/publishing-package-on-test-pypi/install dependenciespip install pipdeptree
pip install twinebuild your python codebasepython setup.py sdist bdist_wheelpublist to testpypitwine upload --repository-urlhttps://test.pypi.org/legacy/dist/*publish to pypitwine upload dist/*RUNNING UNIT TESTSTo run unit tests - goto src directory - make sure you are in parent of tests (where all the test file resides)Run the following commandpython -m unittest discover
Package: jericho-validator
jericho-validatorValidate arbitrary image uploads from incoming data urls while preserving file integrity but removing EXIF and unwanted artifacts and RCE exploit potential.InstallationPyPi:pip install jericho-validatorManually:python setup.py installExample Usagefromrequestsimportgetfromjericho_validatorimportJerichoexample_b64="https://raw.githubusercontent.com/hostinfodev/jericho-validator/main/example/example.png.b64"b64_url=get(example_b64).textdeftest_valid_b64(b64_url):try:# Check the data URL (image)j=Jericho.jericho(b64_url)exceptJericho.Exceptions.ImageTooLarge:print('Image is too large.')exceptJericho.Exceptions.EmptyFileName:print('File name is empty.')exceptJericho.Exceptions.UnsupportedImageType:print('Image type not supported.')exceptExceptionase:print(e)ifj.isValid:print('Image is valid.')print('Image size in bytes: '+str(j.sizeBytes))print('Image dimensions: '+str(j.dimensions))print('Image filename: '+j.filename)print('Image extension: '+j.extension)print('Image format prefix: '+j.formatPrefix)else:print('Image is invalid.')if__name__=='__main__':test_valid_b64(b64_url)