Saravanan666/pypi-org huggingface dataset:
Package: sdmx2json-ld
SDMX to JSON-LD ParserSDMX (Turtle) to NGSI-LD (JSON-LD) converterA SDMX to JSON-LD parser to communicate with FIWARE Context Brokers using ETSI NGSI-LD.Explore the docs »View Demo·Report Bug·Request FeatureAbout The ProjectA SDMX in RDF Turtle 1.1 format parser to generate valid JSON-LD and send to FIWARE Context Brokers using ETSI NGSI-LD.It is based on aEBNF LALR(1) grammar.This project is part of INTERSTAT. For more information about the INTERSTAT Project, please check the urlhttps://cef-interstat.eu.(back to top)DependenciesThe dependencies of the sdmx2jsonld python package are the following:Lark - a modern general-purpose parsing library for Python.hi-dateinfer - a python library to infer date format from examples.Loguru - a library which aims to bring enjoyable logging in Python.Requests - an elegant and simple HTTP library for Python, built for human beings.RDFLib - a pure Python package for working with RDF.For more details about the versions of each library, please refer torequirements.txt.(back to top)Installing SDMX2JSON-LD and Supported VersionsSDMX2JSON-LD is available on PyPI:$python-mpipinstallsdmx2jsonldSDMX2JSON-LD officially supports Python 3.10+.(back to top)UsageTo execute the python module you can follow the following code to parse the RDF Turtle file to generate the JSON-LD
content to be sent to the FIWARE Context Broker:fromsdmx2jsonld.transform.parserimportParserfromsdmx2jsonld.exceptionsimportUnexpectedEOF,UnexpectedInput,UnexpectedTokenfile_in=open("structures-accounts.ttl")generate_files=True# Start parsing the filemy_parser=Parser()try:my_parser.parsing(content=file_in,out=generate_files)exceptUnexpectedTokenase:print(e)exceptUnexpectedInputase:print(e)exceptUnexpectedEOFase:print(e)Where:file_inis the RDF Turtle content that can be a string in StringIO class or a read file in TextIOWrapper class.file_outis a boolean variable to indicate if we want to save the JSON-LD parser content into files (True) or we
want to show the content in the screen (False).(back to top)ContributingContributions are what make the open source community such an amazing place to learn, inspire, and create.
Any contributions you make aregreatly appreciated. If you have a suggestion that would make this better,
please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
Don't forget to give the project a star! Thanks again!Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull Request(back to top)ContactFernando López -@flopezaguilar-fernando.lopez@fiware.orgProject Link:https://github.com/flopezag/IoTAgent-Turtle(back to top)LicenseDistributed under the Apache2.0 License. SeeLICENSEfor more information.(back to top)
Package: sdmxthon
SDMXthonSDMXthon is an open source Python library implementing theSDMX 2.1 information modelMain linksBug Tracker and Enhancements:https://github.com/Meaningful-Data/sdmxthon/issuesDocumentation:https://docs.sdmxthon.meaningfuldata.euSource Code:https://github.com/Meaningful-Data/sdmxthonChangelog:https://docs.sdmxthon.meaningfuldata.eu/changelog.htmlPyPi:https://pypi.org/project/sdmxthon/FeaturesReading and writing SDMX-ML and SDMX-CSVPandas connector (SDMX to Pandas, Pandas to SDMX)Data validationMetadata validationInteraction with SDMX APIs and Fusion Metadata Registry
Package: sdn-manager
Copyright © 2016-2018SoftFIREandTU Berlin. Licensed underApache v2 License.SDN ManagerThe SoftFIRE SDN Manager is in charge of managing access to the SDN
resources provided by some testbeds in SoftFIRE.The SDN Manager keeps track of the API endpoints towards the SDN proxy
services.The SDN Manager uses the following experiment Lifecycles:ListProvisionReleaseUponlist resourcesthe SDN manager returns a list of available SDN
endpoints to the Experimenter.To actually use an SDN resource in an experiment anSDNResourcehas to
be included in the experiment descripton that matches a resource ID
returned bylist resources.Currently supported SDN Endpoints¶Each testbed can provide a different implementation of SDN resources.
The current version of the SoftFIRE SDN middleware provides access to
two types of SDN controllers:The Frauhofer FOKUS testbed uses its own implementation of an SDN
controller named OpenSDNCore.The Ericsson testbed provides access to OpenDayLight SDN controllers.WorkflowThe figure below depicts the workflow of the NFV Manager.For more information on how to use the SDN resources visit thedocumentation.Technical RequirementsThe SDN Manager requires Python 3.5 or higher.Installation and configurationYou can install the SDN Manager using pip:pip install sdn-managerand then start it with thesdn-managercommand.Or you can run it from source code by cloning the git repository,
installing the dependencies as specified in thesetup.pyfile and
executing thesdn-managerscript.The SDN Manager needs a configuration file present at/etc/softfire/sdn-manager.ini. An example of the configuration file
can be foundhere.Issue trackerIssues and bug reports should be posted to the GitHub Issue Tracker of
this project.What is SoftFIRE?SoftFIRE provides a set of technologies for building a federated
experimental platform aimed at the construction and experimentation of
services and functionalities built on top of NFV and SDN technologies.
The platform is a loose federation of already existing testbed owned and
operated by distinct organizations for purposes of research and
development.SoftFIRE has three main objectives: supporting interoperability,
programming and security of the federated testbed. Supporting the
programmability of the platform is then a major goal and it is the focus
of the SoftFIRE’s Second Open Call.Licensing and distributionCopyright © [2016-2018] Sof
Package: sd-nn
sdNNimplementation of the source differential neural network.https://iopscience.iop.org/article/10.1088/0957-0233/23/10/105101Free software: BSD licenseDocumentation:https://sdnn.readthedocs.io.IntroThe sdNN is a special type of neural networks that aims to improve the GPS accuracy in real time.
A detailed explanation is provided in the scientific paper:https://iopscience.iop.org/article/10.1088/0957-0233/23/10/105101Feel free to use the repo if you are working on a similar project.FeaturesPytorch ImplementationKeras ImplementationInstallationInstall the stable release:$pipinstall-UsdNNtake a look at the docs if you want to install from source.History0.1.0 (2020-03-14)First release on PyPI.
Package: sdnoise
PySDNoiseA Python wrapper for noise functions with derivatives.Python wrapper forStefan Gustavson'ssimplex noise
functions with analytical derivates, which can be foundhere.StatusThis project is still under active development and has not yet reached a stable
version until v1.0.0 So when using this code currently expect random error and
dragons.Usagefromsdnoiseimportsdnoise2n,dx,dy=sdnoise2(25.52,30.06)Downloadhttps://github.com/open-terra/pysdnoise
Package: sd-notify
sd_notifySimple sd_notify(3) client functionality implemented in Python 3.Usage:import sd_notify

notify = sd_notify.Notifier()
if not notify.enabled():
    # Then it's probably not running is systemd with watchdog enabled
    raise Exception("Watchdog not enabled")

# Report a status message
notify.status("Initialising my service...")
time.sleep(3)

# Report that the program init is complete
notify.ready()
notify.status("Waiting for web requests...")
time.sleep(3)

# Report an error to the service manager
notify.notify_error("An irrecoverable error occured!")
# The service manager will probably kill the program here
time.sleep(3)Author:stig@stigok.comDec 2019Reference<class 'sd_notify.Notifier'>_send(msg)Send stringmsgas bytes on the notification socketenabled()Return a boolean stating whether watchdog is enablednotify()Report a healthy service statenotify_error(msg=None)Report a watchdog error. This program will likely be killed by the
service manager.Ifmsgis not None, it will be reported as an error message to the
service manager.ready()Report ready service state, i.e. completed initialisationstatus(msg)Set a service status message
Package: sdnotify-wrapper-py
sdnotify-wrapper-pyThis project provides a command line toolsdnotify-wrapper, that can be used
to send a readiness notification from a service to systemd, by simply writing a
newline to stdout. This can be an alternative tosd_notify(3)orsystemd-notify(1), if you don't want your service to depend on systemd.InstallationThere's a package published on PyPi, so it can be installed either withpip,
or globally withpipx:$ sudo PIPX_HOME=/opt/pipx PIPX_BIN_DIR=/usr/local/bin pipx install sdnotify-wrapper-pyUsageIn your service write one line to stdout whenever the service is ready (make
sure to write logs to stderr instead). For example in Python (characters other
than a newline are ignored):print("ready",flush=True)Or in C:write(1,"\n",1)Then create a systemd service file withType=notify, e.g. if your service
would be started withmy-service --foo bar:[Unit]Description=My Service[Service]Type=notifyNotifyAccess=allExecStart=/usr/local/bin/sdnotify-wrapper my-service --foo bar[Install]WantedBy=multi-user.targetsdnotify-wrapperwill then connect to the stdout of your service, notify
systemd when it reads a newline and exit.Why Python?sdnotify-wrapperis a tool originally written by Laurent Bercot:sdnotify-wrapper.c. Unfortunately this tool is not packaged for any of
the major Linux distributions, so it's not a great user experience if your
service requires this mechanism.I chose to reimplement this tool in Python mainly, because it's easier to
install it with a Python package manager. In doing this, I hope this readiness
notification mechanism will be adopted by more projects and the original tool
will be packaged by more distributions.
Package: sdo-citations
SDO Bibtex entry generatorThis project aims to generateBiBTeXfiles that
can be used when citing3GPPspecifications. The input is a
document list exported from the3GPP Portal.Installationpip install sdo-citationsInstructionsGo to the3GPP PortalGenerate the list of specifications you want.Download to Excel and save fileRunsdo-citations -i exported.xlsx -o 3gpp.bibUse in LaTeX.Optionallyuse the provided3gpp.bibdirectly.Things to noteThe outputbibtexclass is set to@techreport.If you add the option--xelatex, break-symbols\-will be used in url-fields.The version and date are read from 3gpp.org, but it is slow so it takes a while to parse the list. If you find an easy solution to this, let me know.Example output@techreport{3gpp.36.331,
 author = {3GPP},
 day = {20},
 institution = {{3rd Generation Partnership Project (3GPP)}},
 month = {04},
 note = {Version 14.2.2},
 number = {36.331},
 title = {{Evolved Universal Terrestrial Radio Access (E-UTRA); Radio Resource Control (RRC); Protocol specification}},
 type = {Technical Specification (TS)},
 url = {https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=2440},
 year = {2017}
}AcknowledgmentThis project was forked frommartisak/3gpp-citations
Package: sdof
sdofLightning-fast integration of single degree-of-freedom systems.This package solves scalar differential equations of the form$$
m \ddot{u} + c \dot{u} + k u = f(t)
$$Integration is carried out using a Generalized - $\alpha$ integrator that
is implemented under the hood in highly optimized multi-threaded C code.Generalized - $\alpha$ is an implicit method that allows for high frequency energy
dissipation and second order accuracy. With the right selection of parameters,
the method can be specialized to the Hibert-Hughes-Taylor (HHT), or Newmark
families of integration schemes.Python APIimportnumpyasnpfromsdofimportintegrate,peaks,spectrumk=10.0c=0.1592m=0.2533f=np.sin(np.linspace(0,5*np.pi,100))dt=5*np.pi/100u,v,a=integrate(f,dt,k,c,m)D,V,A=spectrum(f,dt,periods=(0.02,3.0,100),damping=[0.02,0.05])See AlsomdofopenseesSupport
Package: sdo-image-parameter-api
SDO Image Parameter Python APIA Toolkit for Accessing Solar Image DataThis project was created to facilitate accessing the Image Parameter Web API
available athttp://dmlab.cs.gsu.edu/dmlabapi/using a Python package.Developer: Ruqayyah Muse (ruqayyahmuse@gmail.com)Advisor: Dr. Azim Ahmadzadeh (aahmadzadeh1@gsu.edu)RequirementsPython >= 3.8For a list of all required packages, see requirements.txt.Try it OnlineInstall it from PyPIYou can install this package using pip:pip install sdo-image-parameter-apiFile Structure:sdo_image_parameter_api/image_methods.pycontains all the methods used
for retrieving image information. Includes the four accessor methods
described in the next section, as well as the 8 private methods that make
the calls to the Web API.sdo_image_parameter_api/constants.pyincludes all the defined constants
for Format, InfoType, Wave, Size, Param, as well as the URLs to retrieve
information with the Web API.sdo_image_parameter_api/util/converters.pyincludes methods to
convert XML ElementTree objects into NumPy arrays.sdo_image_parameter_api/util/validators.pyincludes methods to
format and validate given time parameters, as well as validate
all other inputted arguments.Method OptionsThere are four methods that return different types of image information.Theget_img_jpeg()method can be used to return an AIA JPEG image, or a
JPEG Parameter image.Theget_img_param()method can be used to
return image parameters of one image of the sun in XML or JSON format.Theget_img_param_range()method can be used to return image
parameters of a range of images of the sun in XML or JSON format.Theget_img_header()method can be used to return image header
information in XML or JSON format.The required parameters for each method and how to run them for each type of
output is explained in more detail in the Notebook (src/demo.ipynb)AcknowledgementsThank you to Dr. Azim Ahmadzadeh for his guidance during the building of
this project.
Package: sdownloader
Suite DownloaderThis is a small program that helps you to download given list of matrices from theSuiteSparse matrix collection[1].InstallationInstall from sourcegitclonehttps://github.com/talhaokur/sdownloader.gitcdsdownloader
pip3install-rrequirements.txt
python3setup.pyinstallInstall from PyPIpip3installsdownloaderUsageusage:sdownloader[-h](-fLIST_FILE|-mM)[-dDESTINATION][-V][-v]DatadownloaderfromSparseSuite.

optionalarguments:-h,--helpshowthishelpmessageandexit-fLIST_FILE,--list-fileLIST_FILEmatrixnamelistfiledestination.-mMmatrixnames.Example:`sdownloader-m"HB/1138_bus;FIDAP/ex37"`-dDESTINATION,--destinationDESTINATIONdestinationpath.Optional,default=currentworkingdirectory.-v,--verbosetoggleverbosemode.-V,--versionshowprogram'sversionnumberandexitTo download more than one matrix with-margument, split names with semicolon.Examples:sdownloader-m"HB/1138_bus;FIDAP/ex37"-ddata
sdownloader-fdata.txt-ddataReferences[1]: Timothy  A.  Davis  and  Yifan  Hu.  “The  University  of Florida  Sparse  Matrix  Collection”.  In: ACM  Trans. Math. Softw. 38.1 (Dec. 2011), 1:1–1:25. ISSN : 0098-3500. DOI : 10.1145/2049662.2049663. URL :http://doi.acm.org/10.1145/2049662.2049663.
Package: sdpa-multiprecision
SDPA for PythonSDPA for Python is a Python 3 wrapper for SDPA (SemiDefinite Programming Algorithm). SDPA is a software package for solving general SDPs based on primal-dual interior-point methods with the HRVW/KSH/M search direction [1].This package is a fork of SDPAP, the Python interface for SDPA provided at theofficial SDPA website. This repository aims to provide Python 3 support for both SDPA andSDPA Multiprecision(fork of SDPA-GMP [4]).Two variants of this package are available on the Python Package Index (PyPI). The package using the SDPA (OpenBLAS) backend can be installed bypipinstallsdpa-pythonThe package using the SDPA Multiprecision (GMP) backend can be installed bypipinstallsdpa-multiprecisionFor usage documentation or to build from source, please see thedocumentation website.HistorySDPA was officially developed between 1995 and 2012 byMakoto Yamashita, Katsuki Fujisawa, Masakazu Kojima, Mituhiro Fukuda, Kazuhiro Kobayashi, Kazuhide Nakata, Maho Nakata and Kazushige Goto[1] [2] [3]. Theofficial SDPA websitecontains an unmaintained version of SDPA.SDPAP was written byKenta Katoas a Python 2 interface for SDPA. Theofficial SDPA websitealso contains an unmaintained version of SDPAP.This package is a Python 3 port of SDPAP. Besides Python 3 support, it also adds support for the multiprecision backend.ReferencesIf you are using SDPA for Python in your research, please cite SDPA by citing the following papers and book chapters. TheBibTex of the belowhas been included in the repository.[1] Makoto Yamashita, Katsuki Fujisawa and Masakazu Kojima, "Implementation and evaluation of SDPA 6.0 (Semidefinite Programming Algorithm 6.0),"Optimization Methods and Software, vol. 18, no. 4, pp. 491–505, 2003, doi:10.1080/1055678031000118482.[2] Makoto Yamashita, Katsuki Fujisawa, Kazuhide Nakata, Maho Nakata, Mituhiro Fukuda, Kazuhiro Kobayashi, and Kazushige Goto, "A high-performance software package for semidefinite programs: SDPA 7,"Research Report B-460Dept. of Mathematical and Computing Science, Tokyo Institute of Technology, Tokyo, Japan, September, 2010.[3] Makoto Yamashita, Katsuki Fujisawa, Mituhiro Fukuda, Kazuhiro Kobayashi, Kazuhide Nakata and Maho Nakata, “Latest Developments in the SDPA Family for Solving Large-Scale SDPs,” inHandbook on Semidefinite, Conic and Polynomial Optimization, M. F. Anjos and J. B. Lasserre, Eds. Boston, MA: Springer US, 2012, pp. 687–713. doi:10.1007/978-1-4614-0769-0_24.[4] Nakata, M. (2010). A numerical evaluation of highly accurate multiple-precision arithmetic version of semidefinite programming solver: SDPA-GMP, -QD and -DD. 2010IEEE International Symposium on Computer-Aided Control System Design, 29–34. doi:10.1109/CACSD.2010.5612693
Package: sdpa-python
SDPA for PythonSDPA for Python is a Python 3 wrapper for SDPA (SemiDefinite Programming Algorithm). SDPA is a software package for solving general SDPs based on primal-dual interior-point methods with the HRVW/KSH/M search direction [1].This package is a fork of SDPAP, the Python interface for SDPA provided at theofficial SDPA website. This repository aims to provide Python 3 support for both SDPA andSDPA Multiprecision(fork of SDPA-GMP [4]).Two variants of this package are available on the Python Package Index (PyPI). The package using the SDPA (OpenBLAS) backend can be installed bypipinstallsdpa-pythonThe package using the SDPA Multiprecision (GMP) backend can be installed bypipinstallsdpa-multiprecisionFor usage documentation or to build from source, please see thedocumentation website.HistorySDPA was officially developed between 1995 and 2012 byMakoto Yamashita, Katsuki Fujisawa, Masakazu Kojima, Mituhiro Fukuda, Kazuhiro Kobayashi, Kazuhide Nakata, Maho Nakata and Kazushige Goto[1] [2] [3]. Theofficial SDPA websitecontains an unmaintained version of SDPA.SDPAP was written byKenta Katoas a Python 2 interface for SDPA. Theofficial SDPA websitealso contains an unmaintained version of SDPAP.This package is a Python 3 port of SDPAP. Besides Python 3 support, it also adds support for the multiprecision backend.ReferencesIf you are using SDPA for Python in your research, please cite SDPA by citing the following papers and book chapters. TheBibTex of the belowhas been included in the repository.[1] Makoto Yamashita, Katsuki Fujisawa and Masakazu Kojima, "Implementation and evaluation of SDPA 6.0 (Semidefinite Programming Algorithm 6.0),"Optimization Methods and Software, vol. 18, no. 4, pp. 491–505, 2003, doi:10.1080/1055678031000118482.[2] Makoto Yamashita, Katsuki Fujisawa, Kazuhide Nakata, Maho Nakata, Mituhiro Fukuda, Kazuhiro Kobayashi, and Kazushige Goto, "A high-performance software package for semidefinite programs: SDPA 7,"Research Report B-460Dept. of Mathematical and Computing Science, Tokyo Institute of Technology, Tokyo, Japan, September, 2010.[3] Makoto Yamashita, Katsuki Fujisawa, Mituhiro Fukuda, Kazuhiro Kobayashi, Kazuhide Nakata and Maho Nakata, “Latest Developments in the SDPA Family for Solving Large-Scale SDPs,” inHandbook on Semidefinite, Conic and Polynomial Optimization, M. F. Anjos and J. B. Lasserre, Eds. Boston, MA: Springer US, 2012, pp. 687–713. doi:10.1007/978-1-4614-0769-0_24.[4] Nakata, M. (2010). A numerical evaluation of highly accurate multiple-precision arithmetic version of semidefinite programming solver: SDPA-GMP, -QD and -DD. 2010IEEE International Symposium on Computer-Aided Control System Design, 29–34. doi:10.1109/CACSD.2010.5612693
Package: sdpchainpy
SDPCHAINSeismology Data Preparation ModuleRoutines and classes providing a consistent interface for Python programs using
the SDPCHAIN protocol, which includes:Create or append to a process-steps.json file at each stepthe process-steps file is read from the input directory and written
to the output directory.  If both directories are the same the new step
is appended to the existing filecommand-line arguments:-d (base_dir)-i (in_dir), can be relative to base directory-o (out_dir), can be relative to base directoryoptional (input_file) or (input_files), will have input directory pre-pendedoptional -of (output_file) or -ofs (output_files), will have output dir pre-pendedoptional -f, forces writing of output file if it already existsFor now, these parameters must have exactly the above names in the files that
use SDPCHAIN, so that setup_paths and ProcessStep process them correctly.
The new ArgParser subclass should eliminate this need, but pre-populating
the argparser with base_dir, in_dir and out_dir, as well as optionally
input_file or input_files, output_file or output_files, and/or -fClassesProcessStepsobject to hold information for a process-steps fileCommand-line RoutinesThese routines perform common functions while following the
SDPCHAIN rules (process-steps file, -i, -o, -d)sdpstep: run a standard command-line programsdpcat: concatenate binary filesToDoAddsdpcode: change net and station codes?
Package: sdpt3glue
The sdpt3glue package serves as glue code to allow semidefinite programming (SDP problems modeled using Cvxpy to be solved using the Matlab-compatible solver SDPT3.SDPT3 can be used in a number of ways:on an installed copy of Matlab with SDPT3,on an installed copy of Octave with SDPT3,using a Docker image of Octave with SDPT3,by sending the problem to the NEOS server and retrieving the answer.
Package: sd-python-wrapper
A python wrapper for the Server Density Api
It runs on both python 2.7 and up to python 3.5Free software: MIT licenseDocumentation:https://apidocs.serverdensity.com/Up and runningThere are two ways of using the api wrapper. Either calling the endpoints from an instance ofApiClientor from an instance of the class of an endpoint such asDevice.fromserverdensity.wrapperimportApiClientfromserverdensity.wrapperimportDevicetoken='2dfae5bf81f65492a40569d39b29ffa3'client=ApiClient(token)device=client.devices.create(data={'name':'testdevice'})# instead of keyword arguments, it can also take a dictionary.device2=Device(token,name='name2')device2.create()# This will create an AttributeError, since name is required to create a# device at some point.device3=Device(token,group='testgroup')CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: sdqc
SDQCThis Python library allows checking the quality of the input data ofSystem Dynamicsmodels developed in Vensim. It usesPySDlibrary to parse the model and load the input data from spreadsheet files.RequirementsPython 3.7+PySD 3.8+pypandoc (and pandoc 2.17+)netCDF4 (version 1.5 for Python 3.7 in Windows and 1.6+ for all other cases)importlib-metadata 2.0 (only required for Python 3.7)ResourcesSee theproject documentationfor information about:InstallationUsageData quality reportingAuthority and acknowledgmentesThis library was developed by@eneko.martin.martinezatCentre de Recerca Ecològica i Aplicacions Forestals (CREAF).This project has received funding from the European Union’s Horizon 2020
research and innovation programme under grant agreement No. 821105.