Saravanan666/pypi-org huggingface dataset:
Package: x4i3
x4i3 - The EXFOR Interface [for Python 3]This packagex4i3is a fork of the originalx4ideveloped by David A. Brown (LLNL, Livermore CA, 94550). This pure python software acts as an interface toExperimental Nuclear Reaction Data (EXFOR)that theInternational Atomic Energy Agency (IAEA)actively maintains.The database resembles a collection of experimental and evaluated nuclear data files in the EXFOR format (*.x4), a structured markup language. The mark-up language is quite complex and the data has legacy issues, such as data sets entered by hand or issues with the strict alignment criteria of FORTRAN-era punch cards. The documentation by David A. Brown describes a few basics of the format. Please use thisdocumentation, the references therein and the other files in thedocfolder. Please also cite the papers about the database if you use these data in your research.The main purpose of this fork is to ensure that such a valuable and complex tool does stays available. Also, the original link for this code is dead and Python 2 is deprecated. As a standalone pure Python package on pip, it may cure derived works from a potential GPL infection.Latest release 1.2.0Update to EXFOR database version dated 2021/03/08.HistoryThis fork emerged originally in 2016 when we tried to benchmark current photo-nuclear interaction codes against experimental data in a project related to Ultra-High Energy Cosmic Rays. One paper that came outhas a quite useful plot (Figure 1). Actually, this figure isan interactive matplotlib applicationthat used the originalx4ias a backend. When a box is clicked x4i gathers experimental data from EXFOR, applies some filtering and visualizes the data against pre-computed model predictions.ExamplesNothing very useful yet. To check out if the installation is successful, try:python examples/get-entry.py --data -s 10504002It should print some fission cross section to stdout.Contributions..are welcome. Also feel free to say hi since I don't know if there is a community who may find this interface useful.Currently there is no development goals beyond basic maintenance.Requirements~1 GB of hard drive spaceInstallationpip install x4i3Note that on first import ~600MB will be downloaded and 22k files will be decompressed to the data directory.Support toolsTo reduce the weight of this package, the database management tools have been moved to a different projectx4i3_toolssince these are for advanced users anyways.DocumentationThere is currently no separate documentation forx4i3. Please use the originaldocumentation. The installation instruction are not valid anymore. There is a detailed but auto-generatedAPI-doc documentation. Untar and enjoy theindex.htmlif you need this.AuthorsDavid A. Brown (LLNL)(x4i)Anatoli Fedynitch(x4i3)Copyright and licenseThis code is distributed under theGNU General Public License (GPLv2) (see LICENSE)without any warranty or guaranty. The full disclaimer and license information is located in theLICENSE. Very unfortunately, the original code is GPLv2 infecting in a nontransparent way all derived works such as this. Be warned!
Package: x509
This is a fork of a fork of a fork of the original project:py3x509 - Python library for parsing X.509
Copyright (C) 2009-2012  CZ.NIC, z.s.p.o. (http://www.nic.cz)Forked fromhttps://github.com/ph4r05/px509Forked fromhttps://github.com/erny/pyx509Forked fromhttps://github.com/hiviah/pyx509Updates by me rename the module to ‘x509’ and update to Python3 only.Copyright (C) 2017 <siege@siege.org> (https://github.com/cniemira/py3x509)Work in progress!DescriptionThis is probably the most complete parser of X.509 certificates in python.Code is in alpha stage! Don’t use for anything sensitive. I wrote it (based on
previous work of colleagues) since there is no comprehensive python parser for
X.509 certificates. Often python programmers had to parse openssl output.AdvantagesI find it less painful to use than parsing output of ‘openssl x509’
somewhat stricter in extension parsing compared to opensslDisadvantagesIt’s slow compared to openssl (about 2.3x compared to RHEL’s openssl-1.0-fips)Currently not very strict in what string types in RDNs it acceptsAPI is still rather ugly and has no documentation yet; code is nasty at some
places (and there’s some old dangling code like pkcs7/verifier.py)Dependenciespyasn1 >= 0.1.7InstallationInstall with pip:pip install py3x509LicenseLGPL v2 or later.See LICENSE.txt.Known bugs and quirksSubject alternative name doesn’t show all subtypes,
but ‘DNS’, ‘dirName’ and ‘email’ are supported.Name constraints don’t distinguish among various GeneralName subtypesSome extensions are not shown very nicely when put in string formatNot all extensions are supportedString types accepted for various RDN subelements are rather too permissiveRDN string conversion does not conform to RFC 4514Badly formed extensions are ignored if not marked criticaleasy to switch to more strict behaviorother clients do this as well; RFC 5280 specifies behavior for unknown
elements in extensions in appendix B.1, but does not cover all cases (e.g.
element exists, but with string type different from spec)TODOCleanup: This module has it’s own pyasn1 models. Look if we can
reuse the pyasn1_modules.rfc2459 X509 cert model.Cleanup: Currently, the signature verifier does not work.
Package: x5092json
x5092jsonProvides a parser and JSON serializer for x509 certificates.This tool can be used to creating a large database of analyzed
certificates.  Provides a command-line tool as well as an importable
module.  Over 400 Million certificates parsed so far.MotivationPyCA-Cryptography (https://github.com/pyca/cryptography) provides a
full set of cryptographic operations for Python programmers, but the
focus of that library is on safety and correctness.  For that reason,
many certificates which one finds "in the wild" are not intializable
as cryptography objects out-of-the-box.  The x5092json package takes
the safety belts off of cyrptography to provide a parser which is
robust to the nonsense which one finds when processing the X509
certificates deployed in the wilds of the Internet.InstallationRequires Python3.  Tested against Python3.5, 3.6, 3.7.  May work
against earlier Py3Ks.  Because this package relies on pyOpenSSL,
which relies on libssl C bindings, your system will need to be able to
build a wheel.  That, in turn, may require such header files as<openssl/opensslv.h>and<pyconfig.h>.  See your distribution's
package manager for these dependencies (or, in the future, I may be
able to push out a pre-compiled package for some systems)---file an
issue if you are interested in this.From PyPI:$pip3installx5092jsonFrom source :$gitclonehttps://github.com/jcrowgey/x5092jsonUsageCan be used as a command line tool:$catmycert.pem|x5092jsonFor example, the above invocation reads a PEM formatted x509
Certificate from STDIN by default, the JSON document is printed on
STDOUT.Can also be imported as a module within a python program.fromx5092jsonimportx509parser# load a pem file from the filesystemf=open('mycert.pem',mode='rb')cert=x509parser.load_certificate(f)x509parser.parse(cert)See the manual for more usage examples and options.AuthorJoshua Crowgey
Package: x52
X52A easy-to-use package to utilize the MFD on the Throttle of the X52 and X52 Pro, with features like displaying text, navigating pages of content and callbacks.The Package is available onPyPiUsage Examplefromsysimportexit# import necessary items from the x52 packagefromx52importX52,X52Page# Setup callback functions for later usedefcallback_func_1():print('hello from callback_func_1')defcallback_func_2():print('hello from callback_func_2')defcallback_func_3():print('hello from callback_func_3')# instantiate an X52 Object and initialize it# if the X52 Object gets garbage collected it gets# deinitializedx52=X52()x52.init()x52Devices=x52.get_x52devices()# Exit if there is no X52 connectedifnotx52Devices:exit(-1)# Select the first detected devicex52Device=x52Devices[0]# Create pages using the X52Page Constructorpage1=X52Page(('This is Item1',callback_func_1),('This is Item2',callback_func_2),('This is Item3',callback_func_3),True)page2=X52Page(('This is a non',None),('non interactive',None),('Page, with cycling text',None),False)# Add pages to the MFDx52Device.page_add(page1)x52Device.page_add(page2)# Endless loop, else program exitswhileTrue:pass
Package: x735-v2.5
# x735-v2.5
This is the safe shutdown script and some python sample code.## InstallAssuming your system is updated, add these packages:### Install dependencies` sudoapt-getinstallpython-smbussudoapt-getinstall pigpiopython3-pigpio`### Add package` sudo pip3 installx735-v2.5`### Add service to systemdcat > sudo /etc/systemd/system/x735fan.service <<- EOM
[Unit]
Description=Run fan for x735 board
After=multi-user.target

[Service]
Type=simple
Restart=always
RestartSec=1
ExecStart=/usr/bin/python3 /usr/local/bin/x735fan run

[Install]
WantedBy=multi-user.target
EOM

sudo systemctl daemon-reload
sudo systemctl enable x735fan.service
sudo systemctl start x735fan.service
sudo systemctl status x735fan.service## Update` sudo pip3 installx735-v2.5-U`# Use` x735fan run  # Run set speed x735fan info # Get fan information `# Develop` python3-mvenv venv pip install-e. `## Deploy to pypi` python setup.py register-rpypi python setup.py sdist upload-rpypi `
Package: x84
An experimental python 2 Telnet (and SSH) BBSthis project is abandoned, so please don’t get too excited! Maybe you
would be more interested inENiGMA½The primary purpose of x/84 is to provide a server framework for building
environments that emulate the feeling of an era that predates the world wide web.It may be used for developing a classic bulletin board system (BBS) – one is
provided as the ‘default’ scripting layer.  It may also be used to develop a MUD,
a text-based game, or a game-hosting server such as done by dgamelaunch.You may access the “default board” provided by x/84 at telnet host 1984.ws:telnet 1984.wsSeeclientsfor a list of compatible clients, though any terminal should be just fine.QuickstartNote that only Linux, BSD, or OSX is supported. Windows might even work, but hasn’t been tested.Installpython2.7andpip. More than likely this is possible through your
preferred distribution packaging system.Install x/84:pip install x84[with_crypto]Or, if C compiler and libssl, etc. is not available, simply:pip install x84Please note however that without the[with_crypto]option, you
will not be able to run any of the web, ssh, and sftp servers, and
password hashing (and verification) will be significantly slower.If you receive an error aboutsetuptools_extnot being found, you
may need to upgrade your installed version of setuptools and try again:pip install -U setuptools pipLaunch thex84.enginepython module:x84Telnet to 127.0.0.1 6023, Assuming absd telnetclient:telnet localhost 6023All data files are written to~/.x84/.  To create a custom board,
you might copy thedefaultfolder of thex/84python module to a
local path, and point thescriptpathvariable of~/.x84/default.inito point to that folder.Simply edit and save changes, and re-login to see them.  Adjust theshow_tracebackvariable to display any errors directly to your
telnet or ssh client.Documentation, Support, Issue TrackingSeeDocumentationfor API and general tutorials, especially thedeveloperssection for preparing a developer’s environment if you wish to contribute
upstream.  Of note, theTerminalinterface is used for keyboard input
and screen output, and is very well-documented inblessed.This project isn’t terribly serious (for example, there are no tests).  See the project ongithubfor source tree. Please note that this project isabandoned.  Feel free to do whatever the heck
you want with it, though, it is Open Source and ISC licensed!
Package: x86cpu
Usescpuidinstruction to get
information about CPU.QueriesOS as well as cpuidto see if the OS / CPU supports AVX instructions.Quickstart>>> from x86cpu import info
>>> print(info.model_display, info.family_display)
(69, 6)
>>> print(info.vendor)
GenuineIntel
>>> print(info.brand)
'Intel(R) Core(TM) i5-4250U CPU @ 1.30GHz'You can run thecpuidcommand directly.  The argument tocpuidgoes
into theEAXregister before calling the CPUID instruction:>>> from x86cpu import cpuid
>>> cpuid(1)
{'eax': 263761L, 'ebx': 17827840L, 'ecx': 2147154879L, 'edx': 3219913727L}Some CPUID commands also care about the value in theECXregister.  You
can set this with a second optional argument tocpuid:>>> cpuid(13, 1)
{'eax': 1, 'ebx': 0, 'ecx': 0, 'edx': 0}The package installs a command line toolx86reportgiving output like
this:$ x86report
x86cpu report
-------------
brand            : Intel(R) Core(TM) i5-4250U CPU @ 1.30GHz
vendor           : GenuineIntel
model (display)  : 69
family (display) : 6
model            : 5
family           : 6
extended model   : 4
extended family  : 0
stepping         : 1
processor type   : 0
signature        : 263761
MMX              : True
3DNow!           : True
SSE              : True
SSE2             : True
SSE3             : True
SSSE3            : True
SSE4.1           : True
SSE4.2           : True
supports AVX     : True
supports AVX2    : TrueCodeSeehttps://github.com/matthew-brett/x86cpuReleased under the BSD two-clause license - see the fileLICENSEin the
source distribution.The latest released version is athttps://pypi.python.org/pypi/x86cpuSupportPlease put up issues on thex86cpu issue tracker.
Package: x9
X9 by PymoduledevNOTE:X9 only works in Python 3.1+Updates1.0.1 - bug fixes in description1.0.0 - initial releaseWhat is X9?X9 is a comprehensive Python module developed bypymoduledev, offering three essential classes that cater to various programming needs. The module includes the following classes:gui: Provides functionalities for creating and managing graphical user interfaces (GUIs) usingtkinter.web: Enables the development of web applications usingwsgiref.simple_server'smake_serverandlogging.maths: An improved version of the standardmathmodule, offering additional mathematical capabilities made usingmath.How to Install X9You can easily install X9 usingpip:pip install x9How do I use X9?X9 is very easy to understand, and you can take an tutorial here right now.GUI ClassTheguiclass facilitates the creation of user-friendly graphical interfaces. Here's a simple example:from x9 import gui

window = gui.new()
window.bg(color='#000000')
window.title('My Window')
window.favicon('path/to/favicon.ico')
window.resize("1880x600")

textbox = window.textbox(placeholder='type here...')
textbox.resize(100)

text = gui.label('Hey!')
gui.font(text, 'Arial', 16, is_bold=True)

button = window.button(value='submit',command=lambda: print(textbox.get()))

window.run()Web ClassWith thewebclass, you can effortlessly build web applications and APIs. Here's a basic example:from x9 import web

app = web() #Create the web instance

def index():
    return '<p>Hello, World!</p>'

def render_html():
    return app.html('index.html') #This will get the contents of the index.html file assuming it is in the same directory as the Python file

app.new(index, '/')

app.new(render_html, '/render-html')

app.run()Maths ClassThemathsclass extends the capabilities of the standardmathmodule. Take advantage of its additional functions:from x9 import maths as ImprovedMath

# Using Algebra functions
a, b, c = 1, -3, 2
roots = ImprovedMath.Algebra.quadratic_formula(a, b, c)
print(f"The roots of the quadratic equation {a}x^2 + {b}x + {c} = 0 are: {roots}")

# Using Calculus functions
coefficients = [1, 2, 3]
x = 2
derivative_at_x = ImprovedMath.Calculus.differentiate_polynomial(coefficients, x)
print(f"The derivative of the polynomial {coefficients} at x={x} is: {derivative_at_x}")

# Using Statistics functions
data = [2, 4, 6, 8, 10]
mean_value = ImprovedMath.Statistics.mean(data)
print(f"The mean of the data {data} is: {mean_value}")

variance_value = ImprovedMath.Statistics.variance(data)
print(f"The variance of the data {data} is: {variance_value}")ContributionsWe welcome contributions from the community to enhance X9 further. Feel free to share your ideas, report bugs, or request new features at the official PyModuleDev website(pymoduledev.neocities.org)LicenseX9 is distributed under the Apache License 2.0. A copy of the License can be found athttps://www.apache.org/licenses/LICENSE-2.0.txt.ContactFor any questions or support, you can reach out to pymoduledev atpxcom@mail.com.
Package: xac
Powering your AI with human friendly explanationsXaipient API Client (xac)Status: Alpha, Version: 0.3.0Documentation:https://xaipient.github.io/xaipient-docs/RequirementsPython 3.6+Installation$pipinstallxacPython APIfromxacimportExplainerExplainer.login('user@domain.com')withExplainer()asgerman_explainer:german_explainer.from_config('tests/sample/configs/german-keras.yaml')global_imps=german_explainer.get_global_importances()global_aligns=german_explainer.get_global_alignments()global_rules=german_explainer.get_global_rules()local_attrs=german_explainer.get_local_attributions(feature_row=4)local_rules=german_explainer.get_global_rules(feature_row=4)counterfactuals=german_explainer.get_counterfactuals(feature_row=4)print(global_imps)print(global_aligns)print(global_rules)print(local_attrs)print(local_rules)print(counterfactuals)See Documentation for more detailsCommandline interface$xaclogin--emailuser@domain.com$xacsessioninit-fgerman-keras.yaml-ngerman_credit$xacjobsubmit-s<SESSION_ID>-elocal_attributions-eglobal_importances--start4--end5$xacjoboutput<JOB_ID>-o/tmp/explns.jsonCommands:
  config    Generate Xaipient YAML config files for customization
  info      Display key information about API
  job       Manage and Generate Explanations with Xaipient API
  jobs      List explanation jobs.
  login     Login with email and password.
  logout    Logout and purge any tokens.
  session   Manage and Create Sessions for Explanations
  sessions  List all created sessions.
  version   Display current version of client and API.See Documentation for more details
Package: x-access-dumper
X-Access-DumperDumps everything web accessible: git repos, files from.DS_Store, sql dumps, backups, configs...Use asdf or pyenv to install latest python version.Install:$pipinstallx-access-dumper
$pipxinstallx-access-dumperUsage:$ x-access-dumper -h
$ x-access-dumper url1 url2 url3
$ x-access-dumper < urls.txt
$ command | x-access-dumper
$ x-access-dumper -vv https://target 2> log.txtTODO:exclude images and media files by default
Package: xact
Xact is a tool for configuring and deploying software intensive systems,
from simulations running on cloud infrastructure to distributed intelligent
sensing systems running on edge devices.Xact defines a unified configuration data structure for specifying component
dependencies and for configuring various types of messaging middleware,
enabling distributed dataflow systems to be rapidly and conveniently
described and deployed.It is intended to support model based systems and software engineering
processes and to be a foundation for future design automation tools.
Package: xacto
XactoCLI Analyzer/GeneratorIntrospect, compose, marshal and export arbitrary callables into a unified,
hierarchical, command-line interface (CLI)Featuresauto-find tools
scan signatures and export as CLI nodeWhyFAST! EASY! natural import usage!--helpis decent!QuickstartInstall:# pip install xactoPrepare:# ln -s $(which xacto) doCreate python file attools/work.py:frompprintimportpprint__all__=["easy","hard","manual"]defeasy(method,speed=16,*tasks):"""The simple version"""pprint(locals())defhard(method,speed=32,*tasks,**params):"""The difficult version"""pprint(locals())classmanual(object):"""The laborious version"""def__call__(self,method,speed,*tasks):pprint(locals())defmethod(self,process):"""Howto perform operation"""defspeed(self,ops=64):"""Operations per second"""deftasks(self,pri,sec,ter):"""Various tasks"""View--help:# ./do work --help
usage: do work OBJECT ...

additional modules:
  OBJECT  := { .do.work }
    easy  The simple version
    hard  The difficult version
    manual
          The laborious versionView object-level--help:# ./do work manual --help
usage: do work manual --method PROCESS --speed [OPS] [tasks [tasks ...]]

The laborious version

positional arguments:
  tasks             Various tasks

optional arguments:
  --method PROCESS  Howto perform operation
  --speed [OPS]     Operations per second

The laborious versionRun tool (function):# ./do work hard --method=cheat --code=iddqd taskN
{'method': 'cheat',
 'params': {'code': 'iddqd'},
 'speed': 32,
 'tasks': ('taskN',)}Run tool (class):# ./do work manual --method=cheap --speed=256 taskN
{'method': 'cheap',
 'self': <do.work.manual object at ...>,
 'speed': '256',
 'tasks': ('taskN',)}Limitationstrue/false quirkyness (default=True means –default flips to False)TODORELEASE!testing: set-like functions, import semantics.. everythinghandle bools betterdetect outputstandard output structureprettify to ttylazy load toolslazy import globals (cpython)bytecode cacheargument forwarding/chainingintegrate with zippy.shelltab-completionauto-reduce common components for aliasesmake xacto object accessible to tools
Package: xactor
XActor is a framework for doing distributed computing in Python,
using the actor model of programming.XActor’s documentation is hosted athttps://xactor.readthedocs.io/en/latestCompiling latest documentationTo compile the latest version of the documentation from source,
please checkdocs/source/index.rst.XActor depends on mpi4py which requires a MPI implementation
and compiler tools be installed on the system.Installing MPICH and mpi4py inside a conda environmentTo create a new virtual environment with conda,
have Anaconda/Miniconda setup on your system.
Installation instructions for Anaconda can be foundhere.
After installation of Anaconda/Miniconda
execute the following commands:$condacreate-nxactor-cconda-forgepython=3mpichmpi4pyThe above command creates a new conda environment calledxactorwith python, mpich and mpi4py installed.The following commands assume you are inside the above conda environment.Building the documentation from sourceTo build and view the documentation as HTML, execute the following commands:$gitclonehttps://github.com/NSSAC/xactor.git$cdxactor$pipinstall-e.$pipinstall-rdocs/requirements.txt$make-Cdocs$<BROWSER-COMMAND>docs/build/html/index.html
Package: xadmin
Drop-in replacement of Django admin comes with lots of goodies, fully extensible with plugin support, pretty UI based on Twitter Bootstrap.Live Demohttp://demo.xadmin.ioUser: adminPassword: adminFeaturesDrop-in replacement of Django adminTwitter Bootstrap based UI with theme supportExtensible with plugin supportBetter filter, date range, number range, etc.Built-in data export with xls, csv, xml and json formatDashboard page with widget supportIn-site bookmarkingFull CRUD methodsScreenshotsGet StartedInstallXadmin is best installed via PyPI. To install the latest version, run:pipinstallxadminor Install from github source:pipinstallgit+git://github.com/sshwsfc/xadmin.gitInstall Requiresdjango>=1.9django-crispy-forms>=1.6.0 (For xadmin crispy forms)django-reversion([OPTION] For object history and reversion feature, please select right version by your django, seechangelog)django-formtools([OPTION] For wizward form)xlwt([OPTION] For export xls files)xlsxwriter([OPTION] For export xlsx files)DocumentationEnglish (coming soon)ChineseChangelogs0.6.0Compact with Django1.9.Add Clock Picker widget for timepicker.Fixed some userface errors.0.5.0Update fontawesome to 4.0.3Update javascript files to compact fa icons new versionUpdate tests for the new instance method of the AdminSite classAdded demo graphsAdded quickfilter plugin.Adding apps_icons with same logic of apps_label_title.Add xlsxwriter for big data export.Upgrade reversion models admin list page.Fixed reverse many 2 many lookup giving FieldDoesNotExist error.Fixed user permission check in inline model.DetailOnline GroupQQ群 : 282936295Run Demo Locallycddemo_app./manage.pymigrate./manage.pyrunserverOpenhttp://127.0.0.1:8000in your browser, the admin user password isadminHelpHelp Translate :http://trans.xadmin.io