Saravanan666/pypi-org huggingface dataset:
Package: xdynamo
This is pre-release software, and needs to be refactored in a few ways and needs more  natural documentation with examples.  Right now the documentation is in the (API Reference) documentation section.  The natural overview/high-level docs have yet to be writtenHere are a few other related libraries I wrote written that are in a much better state with good documentation, if you want to see other examples of my work:https://github.com/xyngular/py-xinjectA simple dependency injection libraryhttps://github.com/xyngular/py-xconFast dynamic configuration retrieverCan create a flat list of config values based on various config sources and paths environment (for environmental differences and so on).https://github.com/xyngular/py-xsettingsCentralize settings for a project.Can be used with xcon (see above).Know immediately if a setting can't be found as soon as it's asked for vs letting the incorrect setting value cause a problem/crash it happen later on, and then having to back-track it.Documentation📄 Detailed Documentation|🐍 PyPiGetting Startedwarning "Alpha Software!"This is pre-release Alpha software, based on another code base and
the needed changes to make a final release version are not yet
completed. Everything is subject to change; and documentation needs
to be written.poetryinstallxdynamoorpipinstallxdynamo
Package: xe-admix
aDMIXPython Boilerplate contains all the boilerplate you need to create a Python package.Free software: BSD licenseDocumentation:https://advance-data-management-in-xenon.readthedocs.io/en/latest/FeaturesImprove in Rucio uploads on a multi-scale levelCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-02-05)First release on PyPI.
Package: xeasy-ml
xeasy-ml1. What is xeasy-mlXeasy-ml is a packaged machine learning framework. It allows a beginner to quickly bui
-ld a machine learning model and use the model to process and analyze his own data. At the same time, we have also realized the automatic analysis of data. During data proces
-sing, xeasy-ml will automatically draw data box plots, distribution histograms, etc., and perform feature correlation analysis to help users quickly discover the value of data.2.InstallationDependenciesxeasy-ml requires:Scikit-learn >= 0.24.1

Pandas >= 0.24.2

Numppy >= 1.19.5

Matplotlib >= 3.3.4

Pydotplus >= 2.0.2

Xgboost >= 1.4.2User installationpip install xeasy-ml3. Quick Start1.Create a new projectCreate a new python file named pro_init.py to initialize the project.fromxeasy_ml.project_init.create_new_demoimportcreate_project
importospro_path=os.getcwd()create_project(pro_path)Now you can see the following file structure in your project.├── Your_project
     ...
│   ├── pro_init.py
│   ├── project
│   │   └── your_project2.Run examplecdproject/your_project

python__main__.py3.View Resultscdproject/your_project_name/result/v1
ls-l├── box   (Box plot)
├── cross_predict.txt （Cross-validation prediction file）
├── cross.txt  （Cross validation effect evaluation）
├── deleted_feature.txt  （Features that need to be deleted）
├── demo_feature_weight.txt  （Feature weights）
├── demo.m   （Model）
├── feature_with_feature  （Feature similarity）
├── feature_with_label   （Similarity between feature and label ）
├── hist    （Distribution histogram）
├── model
├── predict_result.txt  （Test set prediction results）
└── test_score.txt      （Score on the test set）
Package: xeberus-core-library
Xeberus Core Python LibraryXeberus Core Python Library is a repository of reusable Python components to be shared by some Python projects using the Xeberus RESTful API.These components have minimal dependencies on other libraries, so that they can be deployed easily.  In addition, these components will keep their interfaces as stable as possible, so that other Python projects can integrate these components without having to worry about changes in the future.
Package: xebus-core-library
Xebus Core Python LibraryXebus Core Python Library is a repository of reusable Python components to be shared by Python projects using the Xebus RESTful API.These components have minimal dependencies on other libraries, so that they can be deployed easily.  In addition, these components will keep their interfaces as stable as possible, so that other Python projects can integrate these components without having to worry about changes in the future.
Package: xebus-sis-connector-google-sheet
Xebus Google Sheet SIS ConnectorConnector to fetch family data from a school's Google Sheet document.Google Service AccountXebus Google Sheet SIS Connector needs to use theservice accountxebus-family-list-google-sheet@xebus-323504.iam.gserviceaccount.comto get access to the Google sheet that contains the families data of a school organization.Aservice accountis a special kind of account typically used by an application, rather than a person. A service account is identified by its email address, which is unique to the account.  Applications use service accounts to make authorized API calls by authenticating as either the service account itself. When an application authenticates as a service account, it has access to all resources that the service account has permission to access.
Package: xecs
Documentation:https://xecs.readthedocs.ioxecsis a Python library (written in Rust!) for a performant
entity component system (ECS). You can use it to write simulations, games
or any other high-performance piece of software.If you are familiar withBevyandNumPy– the API ofxecsshould be
familiar to you.The goals ofxecsare as follows:Fast: Operations are executed in parallel as much as possible
and the library is written in Rust to be cache friendly and performant.Simple: Data is defined with a dataclass-like syntax and systems are regular
Python functions.Typed: Types form an integral part of the API, making code clean but
also easily verified with type checkers.NumPy-friendly: Our data types can be used seamlessly with NumPy.Python-friendly: User code is regular Python code, allowing
full integration with the Python ecosystem. We avoid things like Numba
which cause pain during debugging and limit use of pure Python libraries.Code PreviewimportxecsasxxclassVelocity(xx.Component):value:xx.Vec2defupdate_positions(query:xx.Query[tuple[xx.Transform2,Velocity]])->None:(transform,velocity)=query.result()transform.translation+=velocity.valueInstallationpipinstallxecs
Package: xecs-pygame
A plugin forxecs, allowing you to render your entities withpygame.UsageFirst, add the plugin to yourxecsapp.importxecsasxxfromxecs_pygameimportPyGamePlugindefmain()->None:app=xx.RealTimeApp()app.add_plugin(PyGamePlugin())Now, when you spawn entities, you can give them aCircle,Polygon,Rectanglecomponent. If you do that,
your entities will be rendered on the screen:importxecsasxxfromxecs_pygameimportCircle,PyGamePlugindefspawn_three_circles(commands:xx.Commands,world:xx.World)->None:transformi,_=commands.spawn((xx.Transform2,Circle),3)transform=world.get_view(xx.Transform2,transformi)transform.translation.x.fill([0,15,30])defmain()->None:app=xx.RealTimeApp()app.add_plugin(PyGamePlugin())app.add_startup_system(spawn_three_circles)app.add_pool(Circle.create_pool(3))app.add_pool(xx.Transform2.create_pool(3))app.run()if__name__=="__main__":main()Further examplesdraw shapesmoving circlesboidsmouse pressesmouse positiontextkeyboardInstallationpipinstallxecs-pygame
Package: xee
Xee: Xarray + Google Earth EngineAn Xarray extension for Google Earth Engine.How to useInstall with pip:pipinstall--upgradexeeInstall with conda:condainstall-cconda-forgexeeThen, authenticate Earth Engine:earthengineauthenticate--quietNow, in your Python environment, make the following imports:importeeimportxarrayNext, initialize the EE client with the high volume API:ee.Initialize(opt_url='https://earthengine-highvolume.googleapis.com')Open any Earth Engine ImageCollection by specifying the Xarray engine as'ee':ds=xarray.open_dataset('ee://ECMWF/ERA5_LAND/HOURLY',engine='ee')Open all bands in a specific projection (not the Xee default):ds=xarray.open_dataset('ee://ECMWF/ERA5_LAND/HOURLY',engine='ee',crs='EPSG:4326',scale=0.25)Open an ImageCollection (maybe, with EE-side filtering or processing):ic=ee.ImageCollection('ECMWF/ERA5_LAND/HOURLY').filterDate('1992-10-05','1993-03-31')ds=xarray.open_dataset(ic,engine='ee',crs='EPSG:4326',scale=0.25)Open an ImageCollection with a specific EE projection or geometry:ic=ee.ImageCollection('ECMWF/ERA5_LAND/HOURLY').filterDate('1992-10-05','1993-03-31')leg1=ee.Geometry.Rectangle(113.33,-43.63,153.56,-10.66)ds=xarray.open_dataset(ic,engine='ee',projection=ic.first().select(0).projection(),geometry=leg1)Open multiple ImageCollections into onexarray.Dataset, all with the same projection:ds=xarray.open_mfdataset(['ee://ECMWF/ERA5_LAND/HOURLY','ee://NASA/GDDP-CMIP6'],engine='ee',crs='EPSG:4326',scale=0.25)Open a single Image by passing it to an ImageCollection:i=ee.ImageCollection(ee.Image("LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318"))ds=xarray.open_dataset(i,engine='ee')Seeexamplesordocsfor more uses and integrations.How to run integration testsThe Xee integration tests only pass on Xee branches (no forks). Please run the
integration tests locally before sending a PR. To run the tests locally,
authenticate usingearthengine authenticateand run the following:USE_ADC_CREDENTIALS=1python-munittestxee/ext_integration_test.pyLicenseThis is not an official Google product.Copyright 2023 Google LLC

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: xeger
XegerLibrary to generate random strings from regular expressions.To install, type:pip install xegerTo use, type:>>> from xeger import Xeger
>>> x = Xeger(limit=10)  # default limit = 10
>>> x.xeger("/json/([0-9]+)")
u'/json/15062213'AboutCode adapted and refactored from the Python libraryrstr by Leapfrog Online(now iProspect),
in turn inspired by the Java libraryXeger.
Package: xe-likelihood
Binwise approximations of the XENON1T likelihood and XENONnT projections for fast inference on arbitrary models.Example XENON1T based inferenceInstallationIn the folder where you’ve downloaded this repository:pipinstall-e.Simple example:fromxe_likelihoodimportBinwiseInference,Spectrumspectrum=Spectrum.from_wimp(mass=50)inference=BinwiseInference.from_xenon1t_sr(spectrum=spectrum)inference.plot_summary(show=True)Will produce something like this:CitationIf you use this package, please cite the following papers:the paper describing this method:https://arxiv.org/abs/2210.07231the paper for the data used:https://arxiv.org/abs/1805.12562
Package: xelpaste
xelpaste is a Django based pastebin, based on thedpasteproject.
It’s intended to run separately but it is also possible to be installed into an existing Django project like a regular app.You can find a live example onhttp://xelpaste.org/.InstallationYou may install this software from your distribution packages, or through pip:$pipinstallxelpasteOnce installed, you must configure it.
The minimal set of settings is the[db]section of the/etc/xelpaste/config.inifile (see below for details).Once this is configured, you must prepare the database:$xelpastectlmigrateThis will create the database; the last step is to point your WSGI server toxelpaste.wsgi.ConfigurationXelpaste will read all configuration files matching/etc/xelpaste/*.ini.
Those are ini-style files, defining the following parameters:Application ([app])General behavior of the application.Options:modestr, the application mode.
Usedevfor local development andprodotherwise.debugbool, whether to enable debug.
Valid values:on,offsecret_keystr,REQUIREDinprodmode.
A secret key for Django security hooksSite ([site])Hosting and URLs.Options:namestr, the name of your site (xelpaste,mypaster, …).base_urlstr, where your site is hosted.
A trailing slash isrequired.assets_urlstr, the URL where assets (CSS, JS, …) are served.
May be a relative URL.admin_mailstr, the email where the admin should be notified.allowed_hostsstr list, comma-separated list of validHost:HTTP headers.
See Django docs for details.Database ([db])Required; these define where snippets will be stored.
Valid options are:enginestr, the engine to choose.
Must be one ofsqlite,mysql,postgresql; default issqlite.namestr, the name of the database, or its path for sqlite.
Defaults to/var/lib/xelpaste/db.sqlite.hoststr, the host of the database server.portint, the port of the database server.userstr, the login to use to connect to the database server.passwordstr, the password for the databaseExamples:; A Postgresql configuration; uses default psql port.[db]engine=postgresqlname=xelpastehost=psql42.local; A sample sqlite configuration.[db]engine=sqlitename=/data/replicated/xelpaste/db.sqliteSnippets ([snippets])Options for snippets behavior.slug_lengthint, the length of the snippet tags.max_contentsize, the maximum size of code snippets.
Valid values include10kB,2MB, …max_filesize, the maximum size for uploads
Valid values include10kB,2MB, …Uploads ([uploads])Options related to private file uploads.dirpath, storage folder for uploads.
Must be writable by the WSGI process.Example:/var/www/xelpaste/uploadsservestr, the file serving mode.xelpasterelies ondjango-sendfileto enhance performance and protection.Valid options:simple,nginx,xsendfile,mod_wsgi.internal_urlstr, the internal URL used by django-sendfile to serve the files.
Package: xemc3
xemc3A library for working with EMC3 simulations using the xarray framework.ExamplesExamples can be found underdocs/examplesand you can try themonline on binderDocumentationThe documentation can be found onread the docsInstallationpipinstallxemc3CitationIf you use xemc3, please cite it usingDOI: 10.5281/zenodo.5562265
Package: xenapi-python
Unofficial python bindings to XAPI (Xen API) for python 2 and 3This is just copied from the official xenapi repository and packaged
as a standalone repository for installation as a package.https://github.com/xapi-project/xen-api/tree/master/scripts/examples/pythonUsageimport XenAPIInstallationpip install xenapi-pythonAuthorsSamuel D.Lotzmade this repo for
convenience copyrights, authors and licenses are in the code.
Package: xenavalkyrie
Python OO API for Xena Valkyrie traffic generator.FunctionalityThe current version supports the following test flow:Load/Build configuration -> Change configuration -> Start/Stop traffic -> Get statistics/captureSupported operations:Login, connect to chassis and reserve portsLoad existing configuration fileBuild configuration from scratchGet/set attributesStart/Stop - transmit, captureStatistics - ports, streams (end to ends) and TPLDsCapture - get captured packetsRelease ports and disconnectMigrate from pyxenamanagerPackage renamed from xenamanager to xenavalkyrieXenaStreamsStats.statistics['rx']:Returns all RX statistics indexed by RX port instead of TPLD object.Installationpip install xenavalkyrieGetting startedUnderxenavalkyrie.test.xena_samplesyou will find some basic samples.See inside for more info.Documentationhttp://pyxenavalkyrie.readthedocs.io/en/latest/Usage notesDo not create XenaManager manually but use the init_xena factoryWhen loading configuration files, first load all files only then manipulate the configuration.Related worksThe package replaces pyxenamanager -https://github.com/xenadevel/PyXenaManagerContactFeel free to contact me with any question or feature request atyoram@ignissoft.com
Package: xenavalkyrie-rest
This package implements stand-alone REST API server to manage Xena Valkyrie chassis.FunctionalityFull REST API with functionality equivalent to the CLI.Installationpip instsll xenavalkyrie-restGetting startedStart the servergunicorn2 xenavalkyrie_rest.wsgi:app -c xenavalkyrie_rest/settings.pyStart the development server./xena_rest_server.pyDocumentationXena CLI does not distinguish between attributes, operations and statistics. All are flat, unstructured, commands.Each object has the following sub-routes - commands, attributes, statistics, operations.
Note that for some objects some of the sub-routes are not applicable and in this case the sub-route is missing.Commands:
- Any raw CLI command.The following sub-routes are abstractions on top of the raw CLI commands represented in the commands sub-route.Attributes:
- Returns all attributes in one call as dictionary
- Allows set of group of attributesStatistics:
- Structured statistics.Operations:
- Strcutured operations. Not supported in first release.CLI documentation -
swagger UI -http://<SERVER>:<PORT>/api
swagger version 2.0 JSON -http://<SERVER>:<PORT>/api/swagger.jsonRelated worksxenavalkyrieContactFeel free to contact me with any question or feature request atyoram@ignissoft.com
Package: xen-bridge
XEN BridgeAn object-oriented Xen API for pythonTested on XCP-ng, but should also work on XenServerInstallfrom pypi usingpip install xen-bridgeUsagefromxenbridgeimportXenConnectionxen=XenConnection('http://XEN_HOSTNAME','root','password')xoa_vm=xen.VM.get_by_uuid('UUID_OF_VM')# Or by name-label:# xoa_vm = xen.VM.get_by_name_label('XOA')[0]print(f'{xoa_vm.name_label}({xoa_vm.uuid})')print(f'VM is a template:{xoa_vm.is_a_template}')xoa_vm.name_description='This is a VM'xoa_vm.start()# Spin up the VMExceptionsWhile calling API methods, XEN might return an error. When this happens, aXenErroris raised. When catching the exception, the error code can be accessed through theerror_codeattribute# Assuming VM is already running:try:xoa_vm.start()# Should throw an errorexceptxenbridge.XenErrorase:print(e.error_code)# Prints 'VM_BAD_POWER_STATE'How it worksFirstly,xenboject.pydefines some helper functions and baseclasses for the endpoints that do the actual work of calling the XMLRPC API and casting the data to the corresponding types.For each class, there is a file corresponding to that class - for example,vm.py. In here, a class that defines the methods and properties can be found. All methods are wrapped using the@XenMethoddecorator that copies the function's signature and replaces its functionality.classVM(XenObject):@XenMethoddefstart(self,start_paused:bool,force:bool)->None:"""Start the specified VM.  This function can only be called with the VM is in theHalted State."""power_state:VmPowerState=XenProperty(XenProperty.READONLY)As the API responds with a string for numbers, enums and Xen objects, the return type annotations are used to cast the objects to the correct type.The XenConnection class is the object that is used to interact with the APIMissing methodsAll API methods are generated from theXenAPI documentationusingdocscraper.py. If there is a method that is missing, you can either:Add it to the corresponding class in the module yourselfCall it using the class'scall(methodname, *args)method and manually cast it to the correct data type
Package: xendit-python
Xendit Python SDKThe official Xendit Python SDK provides a simple and convenient way to call Xendit's REST API
in applications written in Python.Package version: 4.2.0RequirementsPython >= 3.10Getting StartedInstallationInstall directly from Xendit's Github Repository:pipinstallgit+https://github.com/xendit/xendit-python.git(you may need to runpipwith root permission:sudo pip install git+https://github.com/xendit/xendit-python.git)Then import the package:importxenditSetuptoolsInstall viaSetuptools.pythonsetup.pyinstall--user(orsudo python setup.py installto install the package for all users)Then import the package:importxenditAuthorizationThe SDK needs to be instantiated using your secret API key obtained from theXendit Dashboard.
You can sign up for a free Dashboard accounthere.importxenditfromxendit.apisimportBalanceApifrompprintimportpprintxendit.set_api_key('XENDIT_API_KEY')client=xendit.ApiClient()try:response=BalanceApi(client).get_balance('CASH')pprint(response)exceptxendit.XenditSdkExceptionase:print("Exception when calling BalanceApi->get_balance:%s\n"%e)DocumentationFind detailed API information and examples for each of our product's by clicking the links below,InvoicePaymentRequestPaymentMethodRefundBalanceTransactionCustomerPayoutAll URIs are relative tohttps://api.xendit.co.  For more information about our API, please refer tohttps://developers.xendit.co/.Further ReadingXendit DocsXendit API Reference
Package: xenget
XenGetA library for Python to get information from a XenForo forum.UsageInstallation:pipinstallxengetDocumentationThis documentation is temporary, and will be moved to a better place soon.importxengetForumReturns a Forum class. Usage:forum=xenget.Forum("https://yourforum.com")Forum.get_member(id)Returns a Member class. Usage:member=forum.get_member(12345)MemberMember.get_avatar()Returns an image. Usage:member=member.get_avatar()Member.get_banner()Returns an image. Usage:member=member.get_banner()Member.get_username()Returns a string. Usage:member=member.get_username()Member.get_joindate()Returns a string. Usage:member=member.get_joindate()
Package: xenny
XennyXenny's toolUsageInstallpip3installxennyandPython3.9.9(main,Nov212021,03:22:47)[Clang12.0.0(clang-1200.0.32.29)]ondarwin
Type"help","copyright","credits"or"license"formoreinformation.
>>>importxenny.xenny

HiI'mXenny.
欢迎使用本包。
也请不要仅依赖本包。
Donotgogentleintothatgoodnight。

>>>
Package: xenoglossia
IntroductionA programming language specifically designed such that ASTs generated by markov chain are likely to produce programs with meaningful effect—mcc (@mcclure111)July 11, 2015Xenoglossia is a simple string manipulation language, akin to sed. It
was created with the goal of producing surprising, fun-to-read programs
which can be generated in novel manners by a computer.An introduction to the language and its syntax can be found in thedesign document, and the documentation of the
builtin functions can currently be found in the docstrings of thebuiltins module.UsageXenoglossia will install an executable namedxg. To run a program,
callxg--inputSTRING "xenoglossia program"; for example:xg--input"This is the input string""sub 'input' 'output'"You can also pipe input into stdin:echo"This is the input string"|xg"sub 'input' 'output'"Sample programsReplace two words in a sentence:gsub "favorite" "favourite" gsub "color" "colour"Rearrange the words in a sentence, then capitalize the new sentence:burst " " shuffle capitalize