Saravanan666/pypi-org huggingface dataset:
Package: nexiles.tools.api
Author:Stefan Eletzhofer, nexiles GmbHDate:2024-02-27Version:0.5.1License:BSDAbstractThis is the repository of thepythonHTTP APIclientto thenexiles.toolsWindchill API of nexiles GmbH.FeaturesQueryingread and write IBA Attributesup- and download of contentcreate and delete Business Objects (WTPart, WTDocument, Products)usage, used-by, references navigation of parts and epm documentstype information queriesteam, role, user queriesno InfoEngine license needed!Supported Business Objectsnamebusiness objectactions availableorganizationswt.inf.Organizationproductswt.pdm.PDMLinkProductcontainer attributes  parts documents epmdocumentslibrarieswt.inf.library.WTLibrarycontainer attributes  parts documents epmdocumentsprojectswt.projmgmt.admin.Project2container attributes  parts documents epmdocuments
workpackagescabinetswt.folder.Cabinetfolderswt.folder.SubFolderepmdocumentswt.epm.EPMDocumentcontainer attributes history content uses references used_bypartswt.part.WTPartcontainer attributes history content usesdocumentswt.doc.WTDocumentcontainer attributes history contentteamswt.inf.team.ContainerTeamroles participantsgroupswt.org.WTGroupmembersuserswt.org.WTUsertypescom.ptc.core.meta.type.mgmt.server.impl.WTTypeDefinitionattribute_namesreportswt.query.template.ReportTemplateexecuteworkpackagescom.ptc.windchill.wp.WorkPackagecontent container attributesUsage ExampleFor e.g. fetching allWTDocumentswhich match a certain number:>>> from nexiles.tools.api import get_api
>>> api = get_api("http://www.example.com/Windchill", username="fred", password="kaputnik")
>>> docs = api.documents(number="1003*")Fetching a certain document identified by it’sOID:>>> doc = api.document("OR:wt.doc.WTDocument:2342344")
>>> doc.name, doc.number, doc.version
u'Test Document', u'12345345', u'A.3'Fetching thePRIMARY CONTENTof apart:>>> content = api.parts("OR:wt.epm.EPMDocument:4711").content.get(role="PRIMARY", filename="COVER.PRT")For more examples, see the documentation.RequirementsServer Side RequirementsTo use the API, you need a recent version of thenexiles.toolsinstalled on your Windchill server.We currently support Windchill 11.1 and 12.0 .Please contactinfo@nexiles.comfor licensing and deployment information
regarding the server-side package.Client Side RequirementsTo use the API on your clients, you need:a recent python (testing is done with 3.11.7, Python 2.7 finally died)The dependencies listed in thesetup.pyfile.  Note that
these should be installed automatically.DocumentationSeehttp://nexiles.github.io/nexiles.tools.api/
Package: nexinfosys-client
Python client for NIS BackendA Python client package to operate with NIS-BackendNIS stands for "Nexus Information System". It is a software system (a set of software components) developed
as part of project "MAGIC" activities (H2020 grant #689669). NIS-Backend is the main component, an engine capable of interpreting and resolving MuSIASEM (sustainability, water-energy-food nexus, bioeconomic) models expressed using a DSL in spreadsheet form. For more information go tonis-backendrepository at Github.Getting startedPrerequisitesPython 3.xA NIS backend instance has to be running and accessible. The URL of the API endpoint is the required parameter for the construction of the client. See the example in "Basic Usage" section below. For instructions on executingnis-backendplease checkREADME.mdat Github.Installingpipinstallnexinfosys-clientBasic UsagefromnexinfosysimportNISClientc=NISClient("http://localhost:5000/nis_api")# Construct clientc.login("test_user")# Login, using test userc.open_session()# Open a session (needed before submission)fname="<path to XLSX specifying a case study (accessible to the Python interpreter executing this script)>"c.load_workbook(fname)# Load a workbook (see DMP's annex "Case study formatting reference")# Submit the workbook (execute, return a list of issues, if empty or no issues with type==3, successful execution)r=c.submit()success=sum([i.type==3foriinr])==0foriinr:# Print issuesprint(str(i))ifsuccess:r=c.query_available_datasets()# Obtain available datasetsiflen(r)>0:fordsinr:# List available datasetsprint(str(ds))# Query for one of the datasets ("ds1" must exist)r=c.query_datasets([("ds1","csv")])# Write datasetsforcnt,finenumerate(r):fd=open(f[0]+"."+f[1],"wb")fd.write(f[2])fd.close()# Close sessionc.close_session()# Logoutc.logout()AuthorsRafael Nebot. Instituto Tecnológico de Canarias, SA. Departamento de ComputaciónLicenseThis project is licensed under the BSD-3 License - see theLICENSEfile for detailsAcknowledgementsThe development of this software was supported by the European Union’s Horizon 2020 research and innovation programme
under Grant Agreement No. 689669 (MAGIC). This work reflects the authors' view only; the funding agencies are not
responsible for any use that may be made of the information it contains.
Package: nexio-behave
nexio-behaveThe Nexio BehaveFeatures:Table of Contents:InstallationGuideDevelopmentInstallationnexio-behave requires Python 3.9 or above.pipinstallnexio-behave# orpoetryaddnexio-behaveGuideDevelopmentTo develop nexio-behave, install dependencies and enable the pre-commit hook:pipinstallpre-commitpoetry
poetryinstall
pre-commitinstall-tpre-commit-tpre-pushTo run tests:poetryrunpytest
Package: nexis-uni-parser
Nexis Uni ParserThis package can be used to convert NexisUni richtext files to jsonlines format.FeaturesTODORequirementsTODOInstallationYou can installNexis Uni ParserviapipfromPyPI:pip install nexis-uni-parserUsageThere are two main functions that this package provides.Convert an RTF file to plain textConverting an RTF file to a plain text file can be achieved directly by using pandoc. That said, I have included a function that will convert an RTF file to a plain text file since it could be useful. Under the hood, it just usespandoc.frompathlibimportPathfromnexis_uni_parserimportconvert_rtf_to_plain_textinputfile=Path.home().joinpath("nexisuni-file.rtf")output_filepath=convert_rtf_to_plain_text(inputfile)print(output_filepath)>>>/Users/name/nexisuni-file.txtParse Nexis Uni FilesTheparsefunction can be used to parse a single file or a directory. Both produce a gzipped JSON lines file. I choose to convert to a compressed JSON lines file because the text data can get large if all files are read into memory.frompathlibimportPathfromnexis_uni_parserimportparseinputfile=Path.home().joinpath("nexisuni-file.rtf")output_filepath=parse(inputfile)# Reading the data into a pandas dataframe is easy from here.importpandasaspdnexisuni_df=pd.read_json(str(output_filepath),compression="gzip",lines=True)ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,Nexis Uni Parseris free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: nexmo-jwt
Nexmo Python JWT GeneratorPython class to assist with generating JWT tokens for use with the Nexmo API.Learn more aboutAuthenticating with JSON Web Tokens.InstallationTo install, run:pipinstallnexmo-jwtUsageJWTokenGeneratoris a python class that receives theapplication_idandprivate_keyas required parameters in the constructor. Then a token is generated
using thegenerate_token()method.By default the generated token expires after 15 minutes, but this option can be configured using theset_expiration_iatmethod.Generating a JWTTo generate token theapplication_idclaim and theprivate_keyare required. Using Nexmo Account as an example, you could enter to the Applications section and select a specific application. From there you can copy the application_id andGenerate a new Public key, And then download the private key file.Generating a JWT with Private Key ContentsTo generate a JWT with these properties you can use:fromnexmo_jwtimportJWTokenGeneratorgen:JWTokenGenerator=JWTokenGenerator('your-application-id','private key contents')token:bytes=gen.generate_token()Generating a JWT with Private Key PathYou can also provide a Path to the location of your private key:fromnexmo_jwtimportJWTokenGeneratorgen:JWTokenGenerator=JWTokenGenerator('your-application-id','/path/to/your/private.key')token:bytes=gen.generate_token()Generating a JWT with Custom ClaimsIt is also possible to generate a JWT with custom data:fromnexmo_jwtimportJWTokenGeneratorgen:JWTokenGenerator=JWTokenGenerator('your-application-id','/path/to/your/private.key')token:bytes=gen.generate_token(payload={"foo","bar"})
Package: nexon_openapi
Nexon OpenAPI Python libraryNexon Python 라이브러리는 넥슨에서 제공하는OpenAPI에 대한 python 인터페이스를 제공합니다.RequirementsPython 3.7 버전 이상Installpipinstallnexon_openapiFeaturesNexon OpeanAPI Python 라이브러리에서 지원하는 기능들은 다음과 같습니다.넥슨 OpenAPI에 대한 동기 및 비동기 클라이언트 지원요청/응답에 대한 강력한 타입 힌트 지원일시적인 오류에 대한 자동 재시도 (408,409,429,500)Supported APIs현재까지 지원되는 API 목록은 다음과 같습니다.바람의나라바람의나라:연메이플스토리메이플스토리M마비노기 영웅전크레이지아케이드히트2V4카트라이더 러쉬플러스FC 온라인UsageAPI 호출 예제는여기에서 확인하실 수 있습니다.importosfromnexon_openapiimportNexonOpenAPIclient=NexonOpenAPI(api_key=os.environ.get("NEXON_OPENAPI_API_KEY")# api_key 값이 주어지지 않은 경우, 기본적으로 환경 변수(`NEXON_OPEN_API_KEY`)를 파싱합니다.)ocid=client.maplestory.get_ocid(character_name="")character_basic=client.maplestory.get_character_basic(ocid=ocid)Async usageAPI 호출 예제는여기에서 확인하실 수 있습니다.importasyncioimportosfromnexon_openapiimportNexonOpenAPIAsyncclient=NexonOpenAPIAsync(api_key=os.environ.get("NEXON_OPENAPI_API_KEY")# api_key 값이 주어지지 않은 경우, 기본적으로 환경 변수(`NEXON_OPEN_API_KEY`)를 파싱합니다.)asyncdefmain()->None:ocid=awaitclient.maplestory.get_ocid(character_name="")character_basic=awaitclient.maplestory.get_character_basic(ocid=ocid)asyncio.run(main())ExamplesAPI 호출 예제는여기에서 확인하실 수 있습니다.RetriesAPI 요청 중에 오류가 발생한 경우, 특저 오류는 2번의 재시도를 하도록 기본적으로 설정되어 있습니다. 네트워크 연결 오류,408(Request Timeout),409(Conflict),429(Rate Limit), 그리고>=500(Internal Server Error)에 해당하는 오류들은 기본적으로 모두 재시도됩니다.max_retries옵션을 사용하여 재시도 설정을 구성하거나 비활성화할 수 있습니다:"fromnexon_openapiimportNexonOpenAPIclient=NexonOpenAPI(max_retries=0)# 기본 값은 2입니다.
Package: nexor
Note:
not recommended for GA yet.Thenexorcommand tries to help reasonable workflow
for Python
which is build-tool agnostic.nexor relock: Createrequirements-<…>.txtfiles for all extra dependencies,
and arequirements.txtwithout any extras.nexor env: Create a virtual environment inWORKON_HOMEor, if one already exists,
install the dependencies in it from the lock file.
By default this isrequirements.txt,
but you can configure inpyproject.tomlundertools.nexordefault_extra to be something else.nexor depend: Add a dependency topyproject.toml.
Also,
by default,
relock the files
and update the env.You can also add new commands to nexor.
[more docs here about how to do it.]
Package: nexport
Overviewnexport is a lightweightPython 3.10+package which enables neural network developers to export the weights and biases of trained networks to useful file types.Table of contentsOverviewTable of contentsCurrent supportInstall & useObjectivesHistoryCreditsLicenseLinksCurrent supportFiletypePyTorchKeras/TensorFlowExportImportExportImportText (.txt)✅✅🚧❌JSON (.json)✅🚧❌❌CSV (.csv)❌❌❌❌XML (.xml)❌❌❌❌Install & useFrom terminal:pip install nexportFrom python environment:import nexportObjectivesExport weights and biases to human-readable fileEnsure compatability with all popular neural network development softwareHistoryThis package is intended to be used in conjunction withinference-engine. As such,nexportwas developed by theinference-enginedevelopers to enable compatability between the two softwares.nexportdoes this by exporting the weights and biases from networks compiled inPyTorch,Keras, andTensorFlowinto standardized human-readable files. These files can be read byinference-engineto instantiate the netwoks in Fortran 2018 for inference.Creditsnexport was created and is currently maintained byJordan Welsman.
Parts of this project were based on prior work byTan Nguyen.Licensenexport is developed and distributed under a Berkeley Laboratory modifiedBSDlicense.NoteSeeLICENSEfor more details.Links:file_folder:See this project on GitHub:gift:See this project on PyPI:cat:Follow me on GitHub:briefcase:Connect with me on Linkedin:email:Send me an email:thought_balloon:Based on this project
Package: nexpose
This is the official Python package for the Python Nexpose API client
library.For assistance with using the library or to discuss different
approaches, please open an issue. To share or discuss scripts which use
the library head over to theNexpose
Resourcesproject.Check out thewikifor
walk-throughs and other documentation. Submit bugs and feature requests
on theissuespage.This library provides calls to the Nexpose XML APIs version 1.1 and 1.2.nexpose-client-python usesSemantic Versioning.
This allows for confident use ofversion
pinningin your requirements file.Release NotesRelease notes are available on theReleasespage.ContributionsWe welcome contributions to this package. Please seeCONTRIBUTINGfor details.Full usage examples or task-oriented scripts should be submitted to theNexpose Resourcesproject. Smaller examples can be added to thewiki.LicenseThe nexpose-client-python library is provided under the 3-Clause BSD
License. SeeLICENSEfor details.CreditsDavinsi LabsRapid7, Inc.Seecontributorsfor more info.
Package: nexpose-py
Python3 bindings and CLI tools forNexposeAPI version 3.cli programsnsc-exporterAPrometheusexporter for
Nexpose scan console metrics.It is a good idea to create a Nexpose user and role specifically for this,
with permissions only to:“View Site Asset Data”“View Group Asset Data”.Asystemdservice file is provided atetc/systemd/system/nexpose-exporter.service,
and a sample env file atetc/defaults/nexpose-exporter.env.
These will be relative to your virtualenv for a virtualenv install,
relative to$HOME/.localfor apip install--userinstall,
and (probably, depending on your OS) relative to/usr/localfor a
root pip install.nsc-janitorMaintenance service for Nexpose scan console.
This will remove sites and reports older than 90 days.It is a good idea to create a Nexpose user and role specifically for this,
with permissions only to:“Manage Sites”“Manage Report Templates”.“View Group Asset Data”“Manage Report Access”Asystemdservice file is provided atetc/systemd/system/nexpose-janitor.service,
and a sample env file atetc/defaults/nexpose-janitor.env.
These will be relative to your virtualenv for a virtualenv install,
relative to$HOME/.localfor apip install--userinstall,
and (probably, depending on your OS) relative to/usr/localfor a
root pip install.nsc-remove-old-reportsnsc-remove-old-siteslibrary usageBasic usage:importnexpose.nexposeasnexposelogin=nexpose.login(base_url='https://localhost:3780',user='some_nexpose_user',password='secure_nexpose_password',)nexpose.engines(nlogin=login)With CLI argument parsing:importnexpose.nexposeasnexposeimportnexpose.argsasnexposeargsparser=nexposeargs.parserparser.description="My nexpose script"parser.add_argument("-f","--foo",help="foo argument",action="store",)args=parser.parse_args()config=nexpose.config(args)nexpose.engines(nlogin=config)print(f"my foo argument was{args.foo}")alternativesnexpose(https://pypi.org/project/nexpose/)
is the official python binding for Nexpose API versions 1.1 and 1.2.nexpose-rest(https://pypi.org/project/nexpose-rest/) is unofficial.
It is (partially?) auto-generated and more comprehensive thannexpose-py.
Package: nexpose-rest
Project TitleAutogenerated simple python client for the nexpose rest interface, currently only get is supported.Getting Startedpip install nexpose-restfrom nexpose_rest import nexpose
c = nexpose.Configuration('https://nexpose.local', 'username', 'password')
if nexpose.testConnection(c):
    print "Connection is working!"
    print nexpose.getAssets(c)LicenseThis project is licensed under the MIT License - see theLICENSEfile for details
Package: nexradaws
This module is designed to allow you to query and download Nexrad
radar files from Amazon Web Services S3 Storage. The real-time feed and full historical archive of original
resolution (Level II) NEXRAD data, from June 1991 to present, is now freely available on Amazon S3 for anyone to use.
More information can be found herehttps://aws.amazon.com/public-datasets/nexrad/.If pyart is installed nexradaws allows you to quickly get pyart objects of downloaded files.nexradaws supports Python 2.7 and Python 3.6.Github -https://github.com/aarande/nexradawsPyPi -https://pypi.python.org/pypi/nexradawsDocs -http://nexradaws.readthedocs.io/en/latest/Required dependenciesboto3pytzsixOptional dependenciespyartInstall with pip:pip install nexradawsVersion 1.1* Bug fix for varying filename extensions over the years (.gz .V06 etc). Thanks Nick Guy for the PR!
Package: nexradutils
NEXRAD quick plotsEasy Python download and plot NEXRAD N0Q compositive reflectivity.
Uses RGB high resolution PNG images of North America.Tested withpytest,flake8andmypytype checking.python-mpipinstall-e.UsageRGB data scaling: NEXRAD N0Q base reflectivity maps.Black: No Data-32 dBZ .. 90 dBZ0.5 dBZ incrementThese data are reduced fidelity RGB images.
We usexarray.DataArrayand plot image by image.
For high-fidelity science data, the lower level data are needed--contact us if interested.importnexradutilsasnqdat=nq.load('~/data/2015-01-19/nexrad/nexrad2015-01-19T01:15:00.png')>>>dat<xarray.DataArray(lat:540,lon:1220,color:3)>array([[[255,255,255],[255,255,255],...,[255,255,255],[255,255,255]]],dtype=uint8)Coordinates:*lat(lat)float6423.023.0523.123.1523.223.2523.323.3523.4...*lon(lon)float64-126.0-125.9-125.9-125.8-125.8-125.7-125.7...*color(color)'R''G''B'Attributes:filename:~/data/nexrad2015-01-19T01:15:00.pngwldfn:Nonetime:2015-01-1901:15:00.latand.lonare vectors of geodetic latitude and longitude respectively, computed based on the.wldfile corresponding to the images.Download NEXRAD dataGetNEXRAD reflectivity datawith parallel download:download-nexradstartstopoutdirexample:
download from 2018-01-01 to 2018-01-02 to~/data/nexrad:download-nexrad2018-01-01T002018-01-03T00~/data/nexradPlot NEXRAD reflectivity dataNEXRAD plots are georegistered viaCartopy,
which is the replacement fordeprecated BasemapPlot all data in directory:plot-nexrad~/data/nexrad/Plot a specific file (subplots if multiple files specified):plot-nexrad~/data/nexrad/2018-01-01T12:35:00.pngPlot via file glob match:plot-nexrad~/data/nexrad/-pat2018-01-01T12*.pngKeogram (specify lat or lon and value):plot-nexrad~/data/2018-01-01/nexrad/-keolat40NotesCoordinatesEPSG:4326 coordinates (WGS84) are in.wldfiles, which are generally the
same for wide time spans of data. The.wld formatis like:0.005 (size of pixel in x direction)
0.0 (rotation of row) (Typically zero)
0.0 (rotation of column) (Typically zero)
-0.005 (size of pixel in y direction)
-126.0 (x coordinate of centre of upper left pixel in map units--here it's WGS84 longitude)
50.0 (y coordinate of centre of upper left pixel in map units--here it's WGS84 latitude)Mass image downscalingFor initial analysis, the original Nexrad image size of 12200 x 5400 pixels may be too high to complete in a reasonable time.
I choose to downsize by a factor of 10, which takes a long time, but is a one-time process.mkdirorig
cp*.pngorig

nicemogrify-scale10%"*.png"If you have trouble with this being very slow, try:MAGICK_TEMPORARY_PATH=/run/shmnicemogrify-scale10%"*.png"
Package: nexsciTAP
# nexsciTAP##### [Documentation](https://caltech-ipac.github.io/nexsciTAP)## NASA Exoplanet Science Institute (NExScI) Python Table Access Protocol (TAP) Server   Version 1.0The TAP (Table Access Protocol) is a standard recommended by the International Virtual Observatory Alliance (http://www.ivoa.net).  It defines a web service for searching tables in relational databases using a dialect of SQL called ADQL (Astronomical Data Query Language) (http://www.ivoa.net/documents/latest/ADQL.html).  ADQL includes functions that support spatial constraints (<i>e.g.,</i> all records with a degree on the sky of specified coordinates).This TAP implementation is written as a Python package and can be installed through PyPI (“pip install”) or built from the source in GitHub.  The distribution includes a module dedicated to translating ADQL to SQL and a spatial indexing package that improves the performance of spatial searches. The code base is compact. It consists of 10 KLOC of Python, and 15 KLOC of spatial indexing code, written in C and deployed as a Python binary extension package.Because there are differences in the implementation of the SQL standard from DBMS to DBMS, we document how to use DB API 2.0 to implement the variants of SQL in common use. Version 1.0 of the TAP server supports Oracle and SQLite3.  It runs on LINUX and requires a a web server such as Apache, a C compiler, and deployment of either an Oracle server or the SQLite3 library.Several AQDL geometry functions are not deployed in Version 1.0. These areINTERSECTS;  AREA and CENTROID;  COORD1, COORD2, and COORDSYS; and REGION.The documentation athttps://caltech-ipac.github.io/nexsciTAPprovides installation and configuration instructions.
Package: nexson
nexsonis a package for handling the “NexSON” format used by theOpen Tree of Life projectto store information about externally produced phylognetic trees.
The package was refactored frompeyotl, which is a more general purpose package.Instructionspython3 -mvenv env
source env/bin/activate
pip install -r requirements.txt
python setup.py develop
python setup.py testperforms the basic installation and test.ThanksThanks toNSFandHITSfor funding support.nexson is primarily written by Mark Holder, Emily Jane McTavish, and Jim Allman,
but see theCONTRIBUTORSfile for a more complete list
of people who have contributed code.Jim Allman, Karen Cranston, Cody Hinchliff, Mark Holder, Peter Midford, and Jonathon Rees
all participated in the discussions that led to the NexSON mapping.The peyotl/test/data/nexson/phenoscape/nexml test file is fromhttps://raw.github.com/phenoscape/phenoscape-data/master/Curation%20Files/completed-phenex-files/Characiformes/Buckup_1998.xmlPhenoscape file (download),NESCent[Feb 16, 2014] The citation for the data is in the nexml doc itself.
Package: nexstar
Nexstar Python APIThis code follows the NexStar Communication Protocol as described in NexStarCommunicationProtocolV1.2.pdfThis latest version of this code is located athttps://github.com/circuitqed/nexstarThis code is forked fromhttps://github.com/sidneycadot/nexstarThe main class is NexstarHandController and supports the following methods:getAlignmentCompletegetDeviceVersiongetGotoInProgressgetLocationgetModelgetPositiongetTimegetTrackingModegetVersiongotoPositionpassthroughsetLocationsetTimesetTrackingModeslew_fixedslew_variable
Package: nexsys
Simple code for complex engineeringNexsys is a "language" for engineers to help solve equations and develop complex mathematical models to ease the design process.The Nexsys crate serves multiple functions and aims to be adaptable to a range of situations. Whether you're solving equations in another application or just trying to crunch out an engineering problem, Nexsys aims to have a solution.ThenexsysRust crate:The nexsys crate offers a broad range of tools for addressing engineering problems. From bare-bones rust implementations of Newton's method to an equation solving engine to a full "interpreter", the nexsys crate offers a number of tools accessible in rust to aid with any engineering problem.ThenexsysPython package:While narrower in scope, the nexsys Python package leveragespyo3to bring the speed of the Nexsys interpreter and solver engine to the ease-of-use of Python. Use theNexsyssolver engine object to programmatically solve systems of equations or thepy_solvefunction to interpret Nexsys code in Python and use the results elsewhere. Just runpip intall nexsysto get started.Thenxc"compiler":For those who just want to solve equations, the nxc compiler offers a cli tool to crunch equations and print solutions in markdown format. Just fire up your equation solver of choice and runnxc ./yourfile.nxsto generate a.mdwith the solution and steps used to acquire it.