Saravanan666/pypi-org huggingface dataset:
Package: xesmf
xESMF is a Python package forregridding.
It isPowerful: It usesESMF/ESMPyas backend and can regrid betweengeneral curvilinear gridswith allESMF regridding algorithms,
such asbilinear,conservativeandnearest neighbour.Easy-to-use: It abstracts away ESMF’s complicated infrastructure
and provides a simple, high-level API, compatible withxarrayas well as basic numpy arrays.Fast: It is faster than ESMPy’s original Fortran regridding engine in serial case, and also supportsdaskforout-of-core, parallel computation.Please seeonline documentation, orplay with example notebooks on Binder.For new users, I also recommend readingHow to ask for helpandHow to support xESMF.
Package: xesn
xesnEcho State Networks powered byxarrayanddask.Descriptionxesnis a python package for implementing Echo State Networks (ESNs), a
particular form of Recurrent Neural Network originally introduced byJaeger (2001).
The main purpose of the package is to enable ESNs for relatively large scale
weather and climate applications,
for example as bySmith et al., (2023)andArcomano et al., (2020).
The package is designed to strike the balance between simplicity and
flexibility, with a focus on implementing features that were shown to matter
most byPlatt et al., (2022).xesn usesxarrayto handle multi-dimensional data, relying ondaskfor parallelization and
to handle datasets/networks that are too large for a single compute node.
At its core, xesn usesnumpyandcupyfor efficient CPU and GPU deployment.InstallationTo install from sourcegitclonehttps://github.com/timothyas/xesn.gitcdxesn
pipinstall-e.Note that additional dependencies can be installed to run the unit test suite::pipinstall-e.[test]pytestxesn/test/*.pyGetting StartedTo learn how to use xesn, check out thedocumentation hereGet in touchReport bugs, suggest features, or view the source codeon GitHub.License and Copyrightxesn is licensed under version 3 of the GNU Lesser General Public License.Development occurs on GitHub athttps://github.com/timothyas/xesn.
Package: xestore
A simple file and document storage utility for XENONnTUsageimportxestorestore=xestore.XeStore()store.login()store.files.upload("a_public_file.txt")store.files.private.upload("a_private_file.txt")store.files['a_public_file'].download(PATH_TO_SAVE)doc={"list":[1,2,3]}store.documents.upload(doc,name="new_document",**metadata)Free software: MITDocumentation:https://xestore.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand thebriggySmalls/cookiecutter-pypackageproject template.
Package: xethhung12-minio
This project is not maintained anymore. Please go forxethhung12_minio_commonxethhung12_minio_download_filexethhung12_minio_upload_fileBuild and deployrm-frdist/*
python-mbuild
pythontwineuploaddist/*-u__token__-p{token}Behind Proxyif the client is connecting to internet though a company proxy server, use the environment variable(http_proxy) to setup the proxy.e.g.http_proxy=http://127.0.0.1:8080Usage of uploadpython-mxethhung12_minio_upload_file\--url{url}\--access-key{access-key}\--secret-key{secret-key}\--bucket{bucket}\--local-file{localfile}\--remote-file{remotefile}Usage  of downloadpython-mxethhung12_minio_download_file\--url{url}\--access-key{access-key}\--secret-key{secret-key}\--bucket{bucket}\--local-file{localfile}\--remote-file{remotefile}
Package: xethhung12-minio-download-file
Buildrm-frdist/*
python-mbuildDeploypythontwineuploaddist/*-u__token__-p{token}Usagepython-mxethhung12_minio_download_file\--url{url}\--access-key{access-key}\--secret-key{secret-key}\--bucket{bucket}\--local-file{localfile}\--remote-file{remotefile}
Package: xethhung12-minio-upload-file
Buildrm-frdist/*
python-mbuildDeploypythontwineuploaddist/*-u__token__-p{token}Usagepython-mxethhung12_minio_upload_file\--url{url}\--access-key{access-key}\--secret-key{secret-key}\--bucket{bucket}\--local-file{localfile}\--remote-file{remotefile}
Package: xethhung12-tg-msg
Build and deployrm-frdist/*
python-mbuild
pythontwineuploaddist/*-u__token__-p{token}Usage of simple sendingpython-mxethhung12_tg_msg\--receiver-id{receiver-id}\--bot-token{bot-token}\--msg{message}# --silent [if want the program close normally, eception still print out but return in normal return code]Usage  of sending through STDINpython-mxethhung12_tg_msg\--receiver-id{receiver-id}\--bot-token{bot-token}\--from-stdin{stdininput}# --silent [if want the program close normally, eception still print out but return in normal return code]
Package: xeuclid
xeuclidis a project of mine that
I've been working on for the past few months.
It's a set of python scripts that lets you do analytic geometry inpython.
You can also draw TikZ diagrams usingtikz_draw.py.It's a work in progress.The following python packages are required to usexeuclid,numpyscipysympypdf2imagePillowTo usetikz_draw.pyyou have to haveLaTeXandtikzpackage installed. You might also need to installImageMagick.InstallationYou can easily installxeuclidusingpip.$pipinstallxeuclidExample UsageYou can find more examples indocs\example_usage_files\.fromxeuclidimport*A=col_vector([2,1])B=col_vector([-1,4])C=col_vector([-2,1])bisector1=angle_bisector(A,B,C)bisector2=angle_bisector(B,C,A)#angle bisector of angle ABC and angle BCAI=bisector1.intersection(bisector2)# intersection of bisector1 and bisector2# I is the incenter of trinagle ABCtikz=Tikz('triangle.tex',preamble=tikz_config.standalone)tikz.usepackage('ifthen')tikz.begin('document')tikz.begin('tikzpicture')tikz.draw_grid(x_range=[-5,5],y_range=[-5,5],color='Black!50')tikz.draw_axis(x_range=[-5,5],y_range=[-5,5],tick_labels=None)tikz.draw_angle(A,C,B,radius=0.3)tikz.draw_angle(C,B,A,radius=0.3)tikz.draw_angle(B,A,C,radius=0.3)tikz.draw_path(A,B,C,cycle=True)tikz.draw_path(I,A)tikz.draw_path(I,B)tikz.draw_path(I,C)tikz.draw_points(A,B,C,I)tikz.node(A,node_config="anchor=west",text=r"$A$")tikz.node(B,node_config="anchor=south",text=r"$B$")tikz.node(C,node_config="anchor=east",text=r"$C$")tikz.node(I,node_config="anchor=north",text=r"$I$")tikz.end('tikzpicture')tikz.end('document')tikz.pdf()#This will compile the TeX file using pdfLaTeX
Package: xevo
xevoThis is a simple set of classes to use for evolutionary coding in a polymorphic way. The central classes are given by "eobj", which implements the basic structure for an object that will be optimized by the second one "evo", which handles the optimization.#eobj
Each eobj needs to at least implement:
defadd(a,b):
how to combine objects a and b
def randomize(s):
return a new completely random version of this class
def mutate(s):
return a sligthly mutated version of this object
def calcstrength(s)->float:
how strong is this objects version
def _copy(s):
copy the specifics of this objectyou can also override shallmaximize->bool to chance if the strength should be maximizedFinallyinit(s) should not contain any nonoptional parameters and call s.initial()There are two simple examples of this object. pion.py tries to find a fixed value (aka np.pi) and bitflip.py tries to maximize the sum of a list of booleans. This is very simple and implements a simple counter, that counts how often any state is evaluated. You can also take a look at the deep learning example below.#evo
This object only needs to implement two functions
def generation(s)->None:
update the objects (stored in s.q)
def _copy(s) -> "subclass of evo":
copy the specifics of this objectHere there is a simple example implemented in crossevo (which is also given in the package), of a batch of object, in which 2 random objects figth against each other and the weaker one is replaced by either a combination of both objects, or by a mutation of the winning one.#erun
Runs an experiment given an evo object and an eobj object. You can also specify the size population in the initializer.
To run the experiment call run(s,maxsteps=1000000,goalstrength=1000000.0), where maxsteps is the maximum number of generation calls that can be called. And by beating goalstrength the run is stopped before.
After the run, you can call show_history(s,log=False) to show a strength history (with an optional logarithmic y axis (if log=True))#machine learning
If you take a look at the eobj deep (deep.py and deeptools.py), you find a simple optimizer object, which tries to find the perfect network setup for a keras dense network setup. So using it requires keras and tensorflow.
Package: xface
安装与升级为了简化安装过程，推荐使用 pip 进行安装pipinstallxface升级 Django Cool 到新版本:pip install -U xface如果需要安装 GitHub 上的最新代码:pip install https://github.com/007gzs/xface/archive/master.zip快速使用注册+识别:import xface
import cv2

face_analysis = xface.FaceAnalysis()
face_analysis.load()
for i in range(5):
    image = cv2.imread("label%d.jpg" % i)
    faces = face_analysis.get_faces(image, max_num=1)
    if faces:
        face_analysis.register_face("label%d" % i, faces[0].feature)
faces = face_analysis.get_faces(image)
res = [
    {
        'bbox': face.bbox,
        'det_score': face.det_score,
        'landmark': face.landmark,
        'landmark_106': face.landmark_106,
        'sim_face_ids': [{'face_id': face_id, 'sim': float(sim)} for face_id, sim in face.sim_face_ids or []]
    }
    for face in faces
]
print(res)
Package: xfacereclib.extension.CSU
FaceRecLib Wrapper classes for the CSU Face Recognition ResourcesThis satellite package to theFaceRecLibprovides wrapper classes for the CSU face recognition resources, which can be downloaded fromhttp://www.cs.colostate.edu/facerec.
Two algorithms are provided by the CSU toolkit (and also by this satellite package): the local region PCA (LRPCA) and the LDA-IR (also known as CohortLDA).For more information about the LRPCA and the LDA-IR algorithm, please refer to the documentation onhttp://www.cs.colostate.edu/facerec/.
For further information about theFaceRecLib, please readits Documentation.
On how to use this package in a face recognition experiment, please seehttp://pypi.python.org/pypi/xfacereclib.paper.BeFIT2012Installation InstructionsThe current package is just a set of wrapper classes for the CSU facerec2010 module, which is contained in theCSU Face Recognition Resources, where you need to download the Baseline 2011 Algorithms.
Please make sure that you have read installation instructions in theDocumentationof this package on how to patch the original source code to work with our algorithms, before you try to go on woth this package.NoteSince the original CSU resources are not Python3 compatible, this package only supports Python2.
For external dependencies of the CSU resources, please read theirREADME.TheFaceRecLiband parts of this package rely onBob, an open-source signal-processing and machine learning toolbox.
ForBobto be able to work properly, some dependent packages are required to be installed.
Please make sure that you have read theDependenciesfor your operating system.DocumentationFor further documentation on this package, please read theStable Versionor theLatest Versionof the documentation.For a list of tutorials on packages obBob, or information on submitting issues, asking questions and starting discussions, please visit its website.
Package: xf-aes-gcm
AES-GCM en-/decryption, with AEAD and support for Xpressfeed passwordsThis package's aim is to be able to handle general AES-GCM encryption and decryption, while still providing the constants and functionality required to inter-operate with S&P Global's Xpressfeed applications, as they use the same algorithm.In essence, this package should be capable of producing and reading the same ciphertexts as the Xpressfeed applications.InstallingFirst, ensure you are installing into a virtual environment:python3 -m venv venv
source ./venv/bin/activate
pip install --upgrade pipThen usepipto install this package and its dependencies:pip install -v \
--upgrade --force-reinstall \
xf-aes-gcmThere may be more recent, or beta, packages in the Test PyPI repository. To obtain one of these packages add the option--extra-index-url https://test.pypi.org/simple/to the above command.Command-line usagexf-aes-gcm[-h|--help] [-v|--version]____________ [-k KEY] [-i IV] [-t TAG_LEN] [-f [F]] [-a AAD]____________ [--no-verify] [{ENC,DEC}]Usexf-aes-gcm-hto bring up more details on these options and their default values, as well as several examples of how to use this package.
Package: xfail
XFail provides a decorator functionxfailto skip expected exceptions.
Similar to unittest.skipIf, butxfailcan specify which exception should be
skipped, and raise if the decorated function is unexpectedly passed (only ifstrictisTrue).InstallSupported python versions are: 2.7, 3.4, 3.5, 3.6Can be installed from PyPI by pip:pip install xfailUsagexfail decoratorxfailaccepts two arguments,exceptionsandstrict.The first argument (exceptions) should be an Exception class to skip (Ex.Exception,AssertionError, and so on). If you want to skip multiple
exceptions, use tuple of them, for example,@xfail((AssertionError,ValueError)).The second argumentstrictshould be a boolean. IfstrictisFalse(by default) and passed unexpectedly, raiseunittest.SkipTestexception,
which will mark the test is skipped. This case is very similar to the function
is decorated byuniteest.skipfunction and the test will be counted as
skipped.If it isTrueand the decorated function did not raise (any of) the
expected exception(s),XPassFailureexception would be raised.
In this case, the test will be counted as fail.fromxfailimportxfail@xfail(IndexError)defget(l,index):returnl[index]l=[1,2,3]get(4)# no errorAlso supports multiple exceptions:@xfail((IndexError,ValueError))defa():'''This function passes IndexError and ValueError
    ...In test script, similar tounittest.TestCase.assertRaises:fromunittestimportTestCasefromxfailimportxfailclassMyTest(TestCase):deftest_1(self):@xfail(AssertionError)defshould_raise_error():assertFalsea()# test passesdeftest_2(self):@xfail(AssertionError,strict=True)defshould_raise_error():assertTruea()# test failes, since this function should raise AssertionError# Can be used for test function@xfail(AssertionError,strict=True)deftest_3(self)assertFalse# This test will fail@xfail(AssertionError,strict=True)deftest_3(self)assertTrueFor more exapmles, seetest_xfail.py.
Package: xfaster
DescriptionImplementation by A. Gambrel, A. Rahlin, C. Contaldi.XFaster is a fast power spectrum and likelihood estimator for CMB datasets. It
has most recently been used for the SPIDER B-mode polarization results, but is
intended to be generically useful for modern CMB observatories.An accompanying paper describing the algorithm can be found here:https://arxiv.org/abs/2104.01172Documentation can be found here:https://spidercmb.github.io/xfaster/xfaster:python packagedocs:documentation on usage, file structure, etc.example:an example configuration for running xfasterTo get started, install xfaster:pip install xfaster
Package: xfce4_terminal_themes
# xfce4-terminal-themesSwitch xfce4-terminal themes with ease!## Installation```bash$ pip install xfce4_terminal_themes```## UsageYou need to create a `$XDG_HOME/xfce4/terminal/themes` file.It's anatomy is:```ini[Theme Name]AnyPropertyThat = xfce4 terminal understands[Theme Name 2]FontName = Terminus 11[Theme Name 3]ColorForeground = #123456```Then, you can list themes, see the current theme, and set themes.### List themes:```sh$ ./xfce4-terminal-themes -lTheme Name 1Theme Name 2Theme Name 3```### Current theme:```sh$ ./xfce4-terminal-themes -cTheme name: Theme Name 2Font name: TerminusFont size: 11```### Set theme:```sh$ ./xfce4-terminal-themes "Theme Name 3"```## Contributing1. Fork it ( https://github.com/[my-github-username]/pianobar_notify/fork )2. Create your feature branch (`git checkout -b my-new-feature`)3. Commit your changes (`git commit -am 'Add some feature'`)4. Push to the branch (`git push origin my-new-feature`)5. Create a new Pull Request
Package: xfcs
Extract metadata and data from FCS (3.0, 3.1) files.Data extraction supports file formats:Mode: List (L)Datatypes: I, F, DImplemented parameter data set options:rawchannel valuesscale values (log10, gain)channel and scale combined into one data setfluorescence compensationlog10 scaled fluorescence compensationMetadata extraction features:support for non-compliant filesmerge or separate csv filesrolling mean for any keyword with a numeric valueappend new fcs files to previously generated metadata csv fileInteractive dashboard plots using thexfcsdashboardadd-on module.InstallationUsing pip:pip install xfcsWithout pip:python setup.py installCommand Line UsageSeeUSAGEfor expanded details.To see a list of available commands and arguments, run ‘’xfcs data –help’’ or ‘’xfcs metadata –help’’extract data: xfcs data [options]
extract metadata: xfcs metadata [options]RequirementsPython 3.5 or greaternumpypandasLicensexfcs is released under the BSD 2-clause license. SeeLICENSEfor details.
Package: xfcsdashboard
Create interactive plots for FCS file metadata (3.0, 3.1).Metadata plots are generated as a self contained html file.
Multiple display options are provided to hide or show parameters, calculated mean values, and customized time range.
By default, all numeric parameters located will be displayed. Parameters displayed can be located on the right side of the plot.
To hide (or display) a parameter, click on its name.
To hide all except one parameter, double click on its name.InstallationUsing pip:pip install xfcsdashboardWithout pip:python setup.py installCommand Line UsageFor stand alone usage:xfcsdashboard -i <metadata.csv>Used in combination with metadata extraction in xfcs (requires xfcs installed):xfcsmeta [--options] --dashboardRequirementsPython 3.5 or greaterpandasplotlyLicensexfcsdashboard is released under the BSD 2-clause license. SeeLICENSEfor details.
Package: xfdfgen
xfdfgenxfdfgen is a Python library for creating xfdf files that can be used to populate pdf form fields.InstallationUse the package managerpipto install xfdfgen.pipinstallxfdfgenUsagefromxfdfgenimportXfdfpdf_document_name='example_document.pdf'dictionary_of_fields={'first_name':'foo','last_name':'bar'}document=Xfdf(pdf_document_name,dictionary_of_fields)output_path='example_out.xfdf'document.write_xfdf(output_path)pdf_document_name should match the name of the document containing the form fields you want to fill in.The keys of the dictionary_of_fields are the form field ids
in the document. To find them, you can useAdobe Acrobat,pdftk,
orPDFescapeif you don't want
to install anything.The output can be imported with various programs/libraries, such aspdftk,Foxit Reader,Adobe Acrobat,
andpypdftk.Alternatively, you can usepdfformfieldswhich this package was created for. pdfformfields is capable
of reading in the metadata of the pdf and
filling in the form for you.To view the xfdf file in a more human readable format, usedocument.pretty_print()which should output<?xml version="1.0" ?>
<xfdf xml:space="preserve" xmlns="http://ns.adobe.com/xfdf/">
	<f href="example_pdf.pdf"/>
	<fields>
		<field name="first_name">
			<value>foo</value>
		</field>
		<field name="last_name">
			<value>bar</value>
		</field>
	</fields>
</xfdf>An example is included in the example folder.CompatibilityThis package has been tested on Windows 10 using Python 3.7LicenseApache License 2.0
Package: xfer
Git plugin for transferring large files across servers.InstallationClone the repo and install with pip or setuptools:gitclonegit@github.com:bprinty/git-xfer.gitpipinstall.ConfigurationTo add a remote server that can be used bygit-xfer, either use theconfigsubcommand:gitxferconfig[<type>]Or manually add the server as a git remote:gitremoteadd<name><url>gitremoteaddserverssh://user@server.com:22/~/git-xfer.gitNote: for remote servers using a port other than 22, please use the format above in defining the remote url.git-xferuses the port specified in the url to do transfer operations.UsageTo start tracking a file with git-xfer, use:gitxferadd<file>To remove a file from tracking with git-xfer, use:gitxferremove<file>To delete a local file and remove it from tracking withgit-xfer, use:gitxferrm<file>To list all the files currently tracked bygit-xfer, use:gitxferlistTo list all the files currently tracked bygit-xferon a remote, use:gitxferlist<remote>To see the difference between locally tracked files and remotely tracked files, use:gitxferdiff<remote>To push locally tracked files to a remote server, use:gitxferpush<remote>To pull tracked files from a remote server, use:gitxferpull<remote>Questions/FeedbackSubmit an issue in theGitHub issue tracker.
Package: xfetus
xfetus - library for synthesis of ultrasound fetal imaging (:baby: :brain: :robot:) :warning: WIP :warning:xfetus is a python-based library to syntheses fetal ultrasound images using GAN, transformers and diffusion models.
It also includes methods to quantify the quality of synthesis (FID, PSNR, SSIM, and visual touring tests).Installation$ pip install xfetusYou can develop locally:Generate your SSH keys as suggestedhere(orhere)Clone the repository by typing (or copying) the following line in a terminal at your selected path in your machine:cd && mkdir -p $HOME/repositories/budai4medtech && cd  $HOME/repositories/budai4medtech
git clone git@github.com:budai4medtech/xfetus.gitReferencesPresentationGood practices in AI/ML for Ultrasound Fetal Brain Imaging SynthesisHarvey Mannering, Sofia Miñano, and Miguel XochicaleUniversity College LondonThe deep learning and computer vision Journal ClubUCL Centre for Advance Research Computing1st of June 2023, 15:00 GMTAbstract
Medical image datasets for AI and ML methods must be diverse to generalise well unseen data (i.e. diagnoses, diseases, pathologies, scanners, demographics, etc).
However there are few public ultrasound fetal imaging datasets due to insufficient amounts of clinical data, patient privacy, rare occurrence of abnormalities, and limited experts for data collection and validation.
To address such challenges in Ultrasound Medical Imaging, Miguel will discuss two proposed generative adversarial networks (GAN)-based models: diffusion-super-resolution-GAN and transformer-based-GAN, to synthesise images of fetal Ultrasound brain image planes from one public dataset.
Similarly, Miguel will present and discuss AI and ML workflow aligned to good ML practices by FDA, and methods for quality image assessment (e.g., visual Turing test and FID scores).
Finally, a simple prototype in GitHub, google-colabs and guidelines to train it using Myriad cluster will be presented as well as applications for Medical Image Synthesis e.g., classification, augmentation, segmentation, registration and other downstream tasks, etc. will be discussed.
The resources to reproduce the work of this talk are available athttps://github.com/budai4medtech/xfetus.CitationsBibTeX to cite@misc{iskandar2023realistic,
      author={
      	Michelle Iskandar and 
      	Harvey Mannering and 
      	Zhanxiang Sun and 
      	Jacqueline Matthew and 
      	Hamideh Kerdegari and 
      	Laura Peralta and 
      	Miguel Xochicale},
      title={Towards Realistic Ultrasound Fetal Brain Imaging Synthesis}, 
      year={2023},
      eprint={2304.03941},
      archivePrefix={arXiv},
      primaryClass={eess.IV}
}ContributorsThanks goes to all these people (emoji key):ADD NAME SURNAME🔬 🤔Sofia Miñano💻🔬 🤔Zhanxiang (Sean) Sun💻🔬 🤔Harvey Mannering💻🔬 🤔Michelle Iskandar💻🔬 🤔Miguel Xochicale💻📖  🔧This work follows theall-contributorsspecification.Contributions of any kind welcome!
Package: xfftspy
xfftspyInstallationpip install xfftspyUsage>>> import xfftspy

# initialize XFFTS boards
>>> cmd = xfftspy.udp_client(host='localhost')
>>> cmd.stop()
>>> cmd.set_synctime(100000)          # synctime : 100 ms
>>> cmd.set_usedsections([1])         # use board : 1
>>> cmd.set_board_bandwidth(1, 2500)  # bandwidth : 2500 MHz
>>> cmd.configure()                   # apply settings
>>> cmd.caladc()                      # calibrate ADCs
>>> cmd.start()                       # start measurement

# receive spectra
>>> rcv = xfftspy.data_consumer(host='localhost')
>>> rcv.clear_buffer()
>>> rcv.receive_once()