Saravanan666/pypi-org huggingface dataset:
Package: internet-sabotage3
Python package to simulate internet failures for testing purposes.This fork fix error in original repository. The library is working at 100%.Installation$pipinstallinternet-sabotage3Usagefrominternet_sabotageimportno_connectionwithno_connection():response=requests.get('http://httpbin.org/ip')orfrominternet_sabotageimportno_connection@no_connectiondeftest_something():passLicenseMIT
Package: internode
Internode is a package to pull data fromhttps://customer-webtools-api.internode.on.net/api/v1.5. To use the Internode API you need a valid account with Internode.RequirementsInstall Python 3.9 (for all users)Pip install requestsUsageConnect to Internode API:import internode
Internode = internode.api("user.name@outlook.com", "password")
Internode.connect()To get service information use the following:Internode.getservice()To get current usage information use the following:Internode.getusage()To get the last day's history information use the following:Internode.gethistory()Full example:Internode = internode.api("user.name@outlook.com", "password")
Internode.connect()
Internode.getservice()
print(Internode.service)
    
Internode.getusage()
print(Internode.usage)
    
Internode.gethistory()
print(Internode.history)
Package: intern_sample
A sample project that exists as an aid to thePython Packaging User Guide’sTutorial on Packaging and Distributing
Projects.This projects does not aim to cover best practices for Python project
development as a whole. For example, it does not provide guidance or tool
recommendations for version control, documentation, or testing.This is the README file for the project.The file should use UTF-8 encoding and be written using ReStructured Text. It
will be used to generate the project webpage on PyPI and will be displayed as
the project homepage on common code-hosting services, and should be written for
that purpose.Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not
a good idea, although a simple “What’s New” section for the most recent version
may be appropriate.
Package: internumpi
interpolaton3D interpolation using NUMBA and MPI4PYGetting startedRequired data:• rank -> Current Processor in execution. More info can be found here:• start_x -> Starting point of the grid in X-direction• end_x -> Ending point of the grid in X-direction• start_y -> Starting point of the grid in Y-direction• end_y -> Ending point of the grid in Y-direction• start_z -> Starting point of the grid in Z-direction• end_z -> Ending point of the grid in Z-direction• nx_old -> Number of points in X-direction in old grid• ny_old -> Number of points in Y-direction in old grid• nz_old -> Number of points in Z-direction in old grid• nx_new -> Number of points in X-direction in new grid• ny_new -> Number of points in Y-direction in new grid• nz_new -> Number of points in Z-direction in new grid• nv -> Number of variables in the data• old_data_path -> Path where the old data is present• old_file_name -> File name where the old data is present (Ex: for filename: input.h5 type input)
• new_data_path -> Path where the new data is present• new_file_name -> File name where the new data is present (Ex: for filename: input.h5 type input)
• key -> Key is required to store the output data in HDF5 format (For optimal data storing)Run the code• pip install internumpi• cd interpolation• mpirun -n #NUM-CORES python main.py --start_x #START_X --end_x #END_X --start_y #START_Y --end_y #END_Y --start_z #START_Z --end_z #END_Z --nx_old #NX_OLD --ny_old #NY_OLD --nz_old #NZ_OLD --nx_new #NX_NEW --ny_new #NY_NEW --nz_new #NZ_NEW --nv #NV --old_data_path #OLD_DATA_PATH --old_file_name #OLD_FILE_NAME --new_data_path #NEW_DATA_PATH --new_file_name #NEW_FILE_NAME --key #KEY
Package: interpals-api
interpals-apiThis Python library provides a simple HTTP API for working with the websitehttps://interpals.net/. It includes:retrieving data by user identifierlisting visitorssearching for users by criterionsviewing and sending messages, deleting chatslisting, adding and removing friendslisting albums and picturesInstallationpip install interpals-apiBasic examplefrominterpals_apiimportSession,Apisession=Session.login('yourusername','yourpassword')api=Api(session)user_info=api.profile('someuser')print(user_info)Since version2.1it supports asynchronous calls for each api method. Below there is a brief asynchonous example:frominterpals_apiimportSessionAsync,ApiAsyncsession=awaitSessionAsync.login('yourusername','yourpassword')api=ApiAsync(session)user_info=awaitapi.profile('someuser')print(user_info)Other examplesBasic example to retrieve user info:frominterpals_apiimportSession,Apisession=Session.login('yourusername','yourpassword')api=Api(session)# This gives info of the user with the link: https://www.interpals.net/someuseruser_info=api.profile('someuser')Dump and load session object:frominterpals_apiimportSession,Apisession=Session.login('yourusername','yourpassword')# Save session into a filewithopen('session.json','w')asf:session.dump(f)# Load session from the saved filewithopen('session.json')asf:session=Session.load(f)Viewing and searching for users:frominterpals_apiimportSession,Apisession=Session.login('yourusername','yourpassword')api=Api(session)# Viewing a certain userapi.view('someuser')# Showing the visitors of your profileusers=api.visitors()print(users)# Searching for usersoptions={'age1':'20','age2':'40','sex':['male','female'],'continents':['AF','AS','EU','NA','OC','SA'],'countries':['US','CA','UK','RU'],'keywords':'travelling','online':True,'cityName':'London'# Or you can use 'city' with its direct code on the website (it's faster)}foruserinapi.search(options,limit=100,timeout=1.0):print(user)To work with friends and pictures, it is necessary to useuidin methods:frominterpals_apiimportSession,Apisession=Session.login('yourusername','yourpassword')api=Api(session)uid=api.get_uid('someuser')# Listing friends of the user 'someuser'friends=api.friends(uid)print(friends)# Adding 'someuser' to friendsapi.friend_add(uid)# Removing 'someuser' from friendsapi.friend_remove(uid)# Listing picturesalbums=api.albums(uid)foralbuminalbums:aid=album['aid']pictures=api.pictures(uid,aid)forpictureinpictures:print(picture['src'])Working with the chat is done throughthread_id:frominterpals_apiimportSession,Apisession=Session.login('yourusername','yourpassword')api=Api(session)uid=api.get_uid('someuser')# Listing your chatsresult=api.chat(count=9,offset=0)print(result['chats'])# Staring new chat (getting thread_id)thread_id=api.get_thread_id(uid)# Show chat messagesmessages=api.chat_messages(thread_id)print(messages)# Send new message to the threadapi.chat_send(thread_id,"Hey! How are you?")# Removing chatapi.chat_delete(thread_id)
Package: interpax
interpax is a library for interpolation and function approximation using JAX.Includes methods for nearest neighbor, linear, and several cubic interpolation schemes
in 1d, 2d, and 3d, as well as Fourier interpolation for periodic functions in
1d and 2d.Coming soon:
- Spline interpolation for rectilinear grids in N-dimensions
- RBF interpolation for unstructured data in N-dimensions
- Smoothing splines for noisy dataInstallationinterpax is installable withpip:pip install interpaxUsageimportjax.numpyasjnpimportnumpyasnpfrominterpaximportinterp1dxp=jnp.linspace(0,2*np.pi,100)xq=jnp.linspace(0,2*np.pi,10000)f=lambdax:jnp.sin(x)fp=f(xp)fq=interp1d(xq,xp,fp,method="cubic")np.testing.assert_allclose(fq,f(xq),rtol=1e-6,atol=1e-5)For full details of various options see theAPI documentation
Package: interpies
# Interpiesinterpiesis a collection of functions to read and analyse geophysical data, especially non-seismic data such as magnetic and gravity data.## Table of Contents[Getting Started](##GettingStarted)
* [Requirements](###Prerequisits)
* [Installation](###Installation)[Examples](##Examples)[Documentation](##Documentation)## Getting Started### RequirementsInterpies requiresPython 3.xand makes use of the following libraries:numpymatplotlibrasterioversion > 1.0 (alpha)gdalscikit-learnscikit-imageOptional:obspyfor reading and writing SEG-Y files (seismic data)geopandasfor reading survey line dataipykernelfor working withinterpiesin Jupyter notebooksbasemapandcartopyfor making maps### Installation#### DependenciesI recommend using [Anaconda](https://www.anaconda.com/what-is-anaconda/) for the installation of both Python and most of the dependencies.Once Anaconda has been installed, make sure theconda-forgechannel is added to your configuration:conda config –add channels conda-forgeNext, I would suggest creating a new environment for working withinterpies. You could start with this command:conda create –name interpies gdal scikit-learn scikit-image matplotlib ipykernel obspy python=3.6Next, installrasterio. You could try usingconda install rasterio. However, the only version available on conda-forge might be the old 0.36. The alpha version 1.0a9 or better is required forinterpiesto work. So carefully check which version is going to be installed first.OnWindows, if the version does not match, simply download the binaries for the required version from Christoph Gohlke’s [website](http://www.lfd.uci.edu/~gohlke/pythonlibs/#rasterio). Then run, for example:pip install rasterio-1.0a12-cp36-cp36m-win_amd64.whlAnd that should do. If you encounter other problems with this part of the installation, please refer to the [rasterio installation](https://mapbox.github.io/rasterio/installation.html).Optionally, you could also installgeopandas, which is great for reading line data from geophysical surveys. And don’t forget to installipykernelto run the notebooks in theinterpiesenvironment.#### interpiesInstallinginterpiesitself is done directly with:pip install interpiesOr you could do it manually by first cloning the current repository:$ git clone https://github.com/jobar8/interpies.gitThen run the following command in the repository directory:$ python setup.py install#### UpgradingBecause a version ofrasterio> 1.0 is not directly available topip, upgrading an existing installation ofinterpiesmust be done without trying to upgrade dependencies (or do it separately). Here is the command:pip install –upgrade –no-deps interpies## ExamplesThe basic usage ofinterpiesis to load gridded data into agridobject, which then gives access to various methods for transforming and displaying the data. So, loading magnetic data and creating a map with the grid is simply done with:`python import interpies grid1 =interpies.open(r'..\data\brtpgrd.gxf')grid1.show() `![image of magnetic data](/doc/mag_survey_example.png)For more advanced examples, please see the notebooks.## DocumentationUnder construction.
Package: inter-pixpy
InterPixPyThis library provides developers with a simple way to interact with the Banco Inter's Pix API.RequirementsPython 3 or higherInstallationpipinstallinter-pixpyUsageimportinterpixpysdk=interpixpy.SDK(client_id="your_app_client_id",client_secret="your_app_client_secret",grant_type="grant_type",scope="your_app_scope",cert_path="path_to_your_cert_file",key_path="path_to_your_key_file",)cob_payload={"calendario":{"expiracao":3600},"devedor":{"cpf":"00000000000","nome":"Xoblinha da Silva",},"valor":{"original":"100.00"},"chave":"99999999999999","solicitacaoPagador":"Pagamento dos serviços prestados.",}result=sdk.cob().create(cob_payload)
Package: interplot
interplotCreatematplotlib/plotlyhybrid plots with a few lines of code.It combines the best of thematplotliband theplotlyworlds through
a unified, flat API.
All the necessary boilerplate code is contained in this module.Currently supported building blocks:scatter plotslinescatterlinescatterhistogramhistboxplotboxplotheatmapheatmaplinear regressionregressionline fillfillannotationstextSupported2D subplotsautomatic color cycling3 different API modesOne line of code>>>interplot.line([0,4,6,7],[1,2,4,8])[plotlylinefigure]>>>interplot.hist(np.random.normal(40,8,1000),interactive=False)[plotlyhistfigure]>>>interplot.boxplot(>>>[>>>np.random.normal(20,5,1000),>>>np.random.normal(40,8,1000),>>>np.random.normal(60,5,1000),>>>],>>>)[matplotlibboxplots]Decorator to auto-initialize plots to use in your methods>>>@interplot.magic_plot>>>defplot_my_data(fig=None):>>># import and process your data...>>>data=np.random.normal(2,3,1000)>>># draw with the fig instance obtained from the decorator function>>>fig.add_line(data,label="my data")>>>fig.add_fill((0,999),(-1,-1),(5,5),label="sigma")>>>plot_my_data(title="My Recording")[plotlyfigure"My Recording"]>>>@interplot.magic_plot_preset(interactive=False,title="Preset Title")>>>defplot_my_data_preconfigured(fig=None):>>># import and process your data...>>>data=np.random.normal(2,3,1000)>>># draw with the fig instance obtained from the decorator function>>>fig.add_line(data,label="my data")>>>fig.add_fill((0,999),(-1,-1),(5,5),label="sigma")>>>plot_my_data_preconfigured()[matplotlibfigure"Preset Title"]Theinterplot.Plotclass for full control>>>fig=interplot.Plot(>>>interactive=True,>>>title="Everything Under Control",>>>fig_size=(800,500),>>>rows=1,>>>cols=2,>>>shared_yaxes=True,>>># ...>>>)>>>fig.add_hist(np.random.normal(1,0.5,1000),row=0,col=0)>>>fig.add_boxplot(>>>[>>>np.random.normal(20,5,1000),>>>np.random.normal(40,8,1000),>>>np.random.normal(60,5,1000),>>>],>>>row=0,>>>col=1,>>>)>>># ...>>>fig.post_process()>>>fig.show()[plotlyfigure"Everything Under Control"]>>>fig.save("export/path/file.html")savedfigureatexport/path/file.htmlResourcesDocumentation:https://interplot.janjo.chSource Code:https://github.com/janjoch/interplotPyPI:https://pypi.org/project/interplot/LicenceDemoView onNBViewer:Try onBinder:Installpip install interplotdev installationgit clone https://github.com/janjoch/interplotcd interplotpip install -e .
Package: interpn
interpnPython bindings to theinterpnRust library for N-dimensional interpolation and extrapolation.Docs:https://interpnpy.readthedocs.io/en/latest/Repo:https://github.com/jlogan03/interpnpyLicenseLicensed under either ofApache License, Version 2.0, (LICENSE-APACHEorhttp://www.apache.org/licenses/LICENSE-2.0)MIT license (LICENSE-MITorhttp://opensource.org/licenses/MIT)at your option.
Package: interpolating-neural-networks
Interpolating Neural NetworksThis repo contains the source code for observingdouble descentphenomena with neural networks inempirical asset pricing data.Fig. A new double-U-shaped bias-variance risk curve for deep neural networks. (Image source:original paper)Deep learning models are heavily over-parameterized and can often get to perfect results on training data. In the traditional view, like bias-variance trade-offs, this could be a disaster that nothing may generalize to the unseen test data. However, as is often the case, such “overfitted” (training error = 0) deep learning models still present a decent performance on out-of-sample test data (Refer above figure).This is likely due to two reasons:The number of parameters is not a good measure of inductive bias, defined as the set of assumptions of a learning algorithm used to predict for unknown samples.Equipped with a larger model, we might be able to discover larger function classes and further find interpolating functions that have smaller norm and are thus “simpler”.There are many other explanations of better generalisation such as Smaller Intrinsic Dimension, Heterogeneous Layer Robutness, Lottery Ticket Hypothesis etc. To read more on them in detail, refer Lilian Weng'sarticle.UsageIn this work, we try to observe double descent phenomena in empirical asset pricing. The observation of double descent is fascinating as financial data are very noisy in comparison to image datasets (good signal to noise ratio).$ pip install interpolating-neural-networksNotes:There are no regularization terms like weight decay, dropout.Each network is trained for a long time to achieve near-zero training risk. The learning rate is adjusted differently for models of different sizes.CitationIf you find this method and/or code useful, please consider citing@misc{interpolatingneuralnetworks,
  author = {Akash Sonowal, Dr. Shankar Prawesh},
  title = {Interpolating Neural Networks in Asset Pricing},
  url = {https://github.com/akashsonowal/interpolating-neural-networks},
  year = {2022},
  note = "Version 0.0.1"
}
Package: interpolative-coding
Python package for binary interpolative coding.How do I install this package?As usual, just download it using pip:pipinstallinterpolative_codingTests CoverageSince some software handling coverages sometime get slightly different results, here’s three of them:Usage examplefrominterpolative_codingimportinterpolative_codinginterpolative_coding([0,2,3],0,5)# ['0', '01', '']
Package: interpolator-for-wrfchem
Interpolator for WRF-CHEMInterpolator forWRF-CHEMis a preprocessing application for using global chemistry model fields with WRF-CHEM. It interpolates the global chemistry model fields to the WRF-CHEM grid and vertical levels. Think of it like WPS but for chemistry fields.Some features:Interpolates 3D fieldsCan do species/size bin mapping through linear combinations of source fieldsPotentially support many global models (currently supports CAMS EAC4)The application is written in Python and is meant to be used a command-line tool. Some potential limitations:The application currently assumes that fields are mixing ratios.The global model fields should be on a regular lat-lon grid.No nesting supportInstallationThe application is available on PyPI and can be installed using pip:pipinstallinterpolator-for-wrfchemUsageThe workflow for using the interpolator is as follows:Use WPS andreal.exeas usual to generate themet_em,wrfinput, andwrfbdyfiles.Download global chemistry model fields (e.g. CAMS EAC4) for the same time period as the WRF simulation.Run the interpolator to interpolate the global chemistry model fields to the WRF-CHEM grid and vertical levels.Run WRF-CHEM.The interpolator will updatewrfinputandwrfbdyfiles to include the chemistry information.The interpolator is a command-line tool and can be run as follows:interpolator-for-wrfchem<globalmodeldatapath><met_empath><wrfinput_d01path><wrfbdy_d01path><speciesmappath><outputpath>Thewrfinput_d01andwrfbdy_d01filesWILL BE MODIFIED!There are some optional flags:--copy-icbc: Make a backup of thewrfinputandwrfbdyfiles before updating them.--no-icand--no-bc: Do not update thewrfinputandwrfbdyfiles, respectively.--diagnostics: Store some diagnostic information in thediag.ncfile.Species mappingIn many cases, the available fields of the global model do not directly correspond to the ones used by the chemistry/dust scheme you want to use in WRF-CHEM. For example, you might have dust concentrations available in different size bins. The application supports "species mapping", through which the WRF-CHEM fields are created through a linear combination of global model fields, after interpolation.Detailed description of the species file format is available inspecies_maps.md.LicenseThe interpolator is licensed under the MIT License. SeeLICENSEfor more information.
Please cite the project if you use it for your research!
Package: interpolatr
interpolatr===========Interpolatr is a command line tool and library for interpolatingconfiguration settings into templatized files. It uses the`jinja2 <http://jinja.pocoo.org/docs/2.9/>`_ library for templating.Usage-----The ``interpolatr`` command-line tool currently supports twoconfiguration sources (command line and YAML; see below) and a singletemplate sink ( file-based jinja2 templates). However, it is easy tosupply your own configuration sources or template sinks if necessary.Usage:::interpolatr [OPTIONS] [<config-class> <config-args>]... [<supplier-class> <supplier-args>]...For example, using builtin config and template suppliers:::interpolatr -D override_setting=value YamlConfigSource --path conf.yaml  ExtensionFileSinkSupplier --target_dir rootConfiguration Sources~~~~~~~~~~~~~~~~~~~~~There are currently two built-in configuration sources for``interpolatr``:1. *Command line*: You can specify configuration values when calling``interpolatr`` using the ``-D`` flag: ``interpolator -D foo=bar``.2. *YAML*: You can specify configuration values in a hierarchical``yaml`` format.The format looks like this: \`\`\`yaml settings: setting\_name:setting\_value setting\_two: other\_valueOptional files to inherit settings from=======================================base: - file/to/inherit-from.yml::# Functionally, this is no different than flattening the list out- [ some/more.yaml, and-even-more.yml ]- final-base-file.yml\`\`\`These settings are populated into a ``ChainedMap``, so any settingsmissing in your top-level configuration will be pulled from itsparent(s).It is simple to define your own configuration sources: see``config.py``. If using the command line, you can use a custom configsource by specifying the fully qualified class path on the command line.Configuration Sinks~~~~~~~~~~~~~~~~~~~Configuration values can currently be written into templatizedconfiguration files. The templating is powered by ``jinja2``, so you mayuse any valid ``jinja2`` expressions to define your configuration files.It should be straightfoward to customize this process as well; see thecode in ``sink.py`` for reference.Notes------  This was developed under Python 2.7, but at least gives theappearance of working under Python 3.-  This is an early version of this tool, so the interfaces are subjectto change.Copyright and License---------------------Copyright 2017, Yahoo Inc.Licensed under the terms of the Apache License, Version 2.0. See theLICENSE file associated with the project for terms.
Package: interpretableai
Interpretable AI Python Interfaceinterpretableaiis a Python package that provides an interface to Interpretable AI algorithms. Through this package, you can utilize the following modules directly in Python:Optimal Predictive Trees (classification and regression)Optimal ImputationOptimal Prescriptive TreesOptimal Survival TreesUsing the PackagePlease see thepackage documentationfor guides on setting up and using the package.
Package: interpretable-tsne
Interpretable t-SNEinterpretable_tsneis an implementation of our gradient-based attributiont technique described in our GLBIO oral presentation: 'Towards Computing Attributions for Dimensionality Reduction Techniques'.To replicate the experiments we performed in our presentation, go to:MattScicluna/interpretable_tsne_experimentSynthetic data experiment demonstrating that our t-SNE attributions can identify the ground truth significant features. Seeour pre-printfor more details.https://github.com/MattScicluna/interpretable_tsne/assets/19255250/789c075c-44fd-48ef-9264-e7dca60a59ceInstallationinterpretable_tsnerequires Python 3.8 or higher to run. It is only available on Linux operating systems.TestPyPiThis code can be installed via TestPyPi using the following command:pip install -i https://test.pypi.org/simple/ interpretable-tsneSourceYou can installinterpretable_tsnefrom source. Just clone this repository and run the following line in the root directory:pip install .Run the unittestspython -m unittest -v tests/*.pyCitationIf you useinterpretable_tsnein your work, please cite us:@article {Scicluna2023.05.12.540592,
        author = {Matthew Crispin Scicluna and Jean-Christophe Grenier and Raphael Poujol and Sebastien Lemieux and Julie Hussin},
        title = {Towards Computing Attributions for Dimensionality Reduction Techniques},
        elocation-id = {2023.05.12.540592},
        year = {2023},
        doi = {10.1101/2023.05.12.540592},
        publisher = {Cold Spring Harbor Laboratory},
        URL = {https://www.biorxiv.org/content/early/2023/05/14/2023.05.12.540592},
        eprint = {https://www.biorxiv.org/content/early/2023/05/14/2023.05.12.540592.full.pdf},
        journal = {bioRxiv}
    }