Saravanan666/pypi-org huggingface dataset:
Package: intStatistics
This package provides statistical indicators for Maximum Accuracy Interval
Arithmetic.
The Interval Arithmetic is a mathematical tool for the solution of problems
related to numerical errors, based on an algebraic system formed by all closed
intervals of Real Line.
The Interval Statistical Indicators are quantitative metrics for analyse population and amostral datasets. When used with Interval Arithmetic provide a high accuracy and confiability.
For more information about this study, see related works:
Package: intstr
for example:import string

ALPHABET = string.ascii_uppercase + string.ascii_lowercase +                string.digits + '-_'


intstr = IntStr(ALPHABET)

s = intstr.encode(1234567)
print s
print intstr.decode(s)


intstr = IntStr(ALPHABET,"$")

s = intstr.encode(-1234567)
print s
print intstr.decode(s)
Package: intuit-oauth
Intuit’s OAuth2 and OpenID Python ClientThis client library is meant to work with Intuit’s OAuth and OpenID implementation. TheAuthClientobject response can be used for User Info API, Accounting API and Payments API. This library supports:Generating Authorization URLGetting OAuth2 Bearer TokenGetting User InfoValidating OpenID tokenRefreshing OAuth2 TokenRevoking OAuth2 TokenMigrating tokens from OAuth1.0 to OAuth2InstallUsingpip:$ pip install intuit-oauthDocumentationUsage and Reference Documentation can be found atoauth-pythonclient.readthedocs.ioSample AppSample app for this library can be found atIntuitDeveloper GitHub OrgIssues and ContributionsPlease open anissueon GitHub if you have a problem, suggestion, or other comment.Pull requests are welcome and encouraged! Any contributions should include new or updated unit tests as necessary to maintain thorough test coverage.LicenseThis library is provided under Apache 2.0 which is foundhere
Package: intuno
# intunointunois a terminal-based note tuning application for pianos and other instruments.  Written in Python, it is available for multiple platforms.## InstallationThe program depends on thepyaudiolibrary, which in turn depends onportaudio, which on a Mac is installed most easily with Homebrew. After cloning this repository, run:` brew update brew install portaudio brew link--overwriteportaudio `On macs, thepyaudioinstallation can sometimes fail because it cannot find the portaudio header and lib files.  To fix, find out where in your Homebrew path the files are and point the installer to them:` pip3 install--global-option='build_ext'\--global-option='-L/opt/homebrew/Cellar/portaudio/19.7.0/lib'\--global-option='-I/opt/homebrew/Cellar/portaudio/19.7.0/include'pyaudio `Now you should be able to install with:` pip install intuno `## TuningRunintunowith:` intuno `This defaults to tuning A in Octave 5.  You can optionally specify a different starting note, for instance to start tuning at Middle C, use:` intuno c3 `The interface shows the currently selected note in the top menu bar, which you can change with the left and right arrow keys.  The raw signal coming from the microphone is rendered with [plotille](https://github.com/tammoippen/plotille) and the filtered signal is shown below it.  For a correctly tuned note, you should see a nice, clean waveform with a green OK status next to its estimated frequency:![OK](resources/screenshot-accurate.png)If the note is out of tune, the bottom waveform will drift, and the frequency estimate will tell you how much you will have to tighten (if the frequency is too low) or loosen (if too high) the string:![Off](resources/screenshot-off.png)For lower- and higher frequency notes, you may need to adjust the volume of your microphone.  If your system’s controls do not give the desired range, you can adjust the software volume with the up and down keys.## OtherFor more information on the how the program works, check out [this notebook](https://loukad.github.io/tuning.html).
Package: intxeger
IntXegerIntXeger (pronounced "integer") is a Python library for generating strings from regular
expressions. It was inspired by thexegerlibrary but
provides additional features such as:Faster than bothxegerandexrex.Array-like indexing for mapping integers to strings which match the regex.Sampling-without-replacement for generating a set of unique strings which match the regex.These features makeIntXegerperfect for applications such as generating unique
identifiers, producing matching strings sequentially, and more!InstallationYou can install the latest stable release of IntXeger by running:pipinstallintxegerQuick StartLet's start with a simple example where our regex specifies a two-character string
that only contains lowercase letters.importintxegerx=intxeger.build("[a-z]{2}")You can check the number of strings that can be generated with this string using
thelengthattribute and generate theith string which matches using theget(i)method.assertx.length==26**2# there are 676 unique strings which match this regexassertx.get(15)=='ap'# the 15th unique string is 'ap'Furthermore, you can generateNunique strings which match this regex using thesample(N)method. Note thatNmust be less than or equal to the length.print(x.sample(N=10))# ['xt', 'rd', 'jm', 'pj', 'jy', 'sp', 'cm', 'ag', 'cb', 'yt']Here's a more complicated regex which specifies a timestamp.x=intxeger.build(r"(1[0-2]|0[1-9])(:[0-5]\d){2}(A|P)M")print(x.sample(N=2))# ['11:57:12 AM', '01:16:01 AM']To learn more about the functionality provided byIntXeger, check out ourdocumentation!BenchmarkThis table, generated bybenchmark.py, shows the amount of time in
milliseconds required to generateNexamples of each regular expression
usingxegerandintxeger.regexNxegerexrexintxeger[a-zA-Z]+1007.363.171.09[0-9]{3}-[0-9]{3}-[0-9]{4}10011.596.250.8[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}1000208.6291.318.28/json/([0-9]{4})/([a-z]{4})1000133.36107.0112.18Have a regular expression that isn't represented here? Check out ourContributing Guideand
submit a pull request!
Package: inu
Inertial Navigation UtilitiesFunctionsThis library provides forward mechanization of inertial measurement unit sensor
values (accelerometer and gyroscope readings) to get position, velocity, and
attitude as well as inverse mechanization to get sensor values from position,
velocity, and attitude. It also includes tools to calculate velocity from
geodetic position over time, to estimate attitude from velocity, and to estimate
wind velocity from ground-track velocity and yaw angle.AccuracyThe mechanization algorithms in this library make no simplifying assumptions.
The Earth is defined as an ellipsoid. Any deviations of the truth from this
simple shape can be captured by more complex gravity models. The algorithms use
a single frequency update structure which is much simpler than the common
two-frequency update structure and just as, if not more, accurate.DualityThe forward and inverse mechanization functions are perfect duals of each other.
This means that if you started with a profile of position, velocity, and
attitude and passed these into the inverse mechanization algorithm to get sensor
values and then passed those sensor values into the forward mechanization
algorithm, you would get back the original position, velocity, and attitude
profiles. The only error will be due to finite-precision rounding.VectorizationWhen possible, the functions are vectorized in order to handle processing
batches of values. A set of scalars is a 1D array. A set of vectors is a 2D
array, with each vector in a column. So, a (3, 7) array is a set of seven
vectors, each with 3 elements. If an input matrix does not have 3 rows, it will
be assumed that the rows of the matrix are vectors.Distribution Statement A: Approved for public release; distribution unlimited.
Package: inuits-module-loader
ReadmeThis library is the same as the Django utils module loader, but without needing Django as dependency.
It is used to load modules/classes based on their dotted string path.Installpip install inuits-module-loaderUsagefrominuits_module_loaderimportimport_stringimport_string("dotted.path.to.your.module.or.class")ExampleThis example will dynamically load classes in the extensions/resources folder that extend the default classes in the application.
Default class: resources.your_file_name.YourClassNameClass in extensions folder: extensions.resources.your_file_name.YourClassNameIt is recommended to name the extension file and class the same as the default class, and import the default class with an alias in your extension class.Extended classfromresources.your_file_name.YourClassNameimportYourClassNameasDefaultYourClassNameclassYourClassName(DefaultYourClassName):defdo_something(self):returnTrueAppfrominuits_module_loaderimportimport_stringimportlogginglogger=logging.getLogger(__name__)# This function will try to load your class from the extension folder and fall back to the default class if there is no extension available for that class.defload_resource(resource:str):try:logger.info(f"Loading{resource}extension.")returnimport_string(f"extensions.resources.{resource}")exceptModuleNotFoundError:logger.info(f"No{resource}extension found, loading core{resource}")returnimport_string(f"resources.{resource}")exceptImportErroraserror:logger.info(f"{error}, loading core{resource}")returnimport_string(f"resources.{resource}")# If you name your extended file and class the same as the default file and class you can easily add or remove classes from the extensions folder without adding additional code in the app.your_class=load_resource("your_file_name.YourClassName")()
Package: inumet-api
INUMET APIINUMET Api wrapper for pythonInstallation$pipinstallinumet_apiExampleGet all the relevant weather data# import the modulefrominumet_apiimportINUMETprint(INUMET('Prado','Montevideo')._get_data())Get Current Conditions# import the modulefrominumet_apiimportINUMETprint(INUMET('Prado','Montevideo').estado_actual())Get the list of stations# import the modulefrominumet_apiimportINUMETprint(INUMET().estaciones())
Package: inupypi
Installation InstructionsFrom sourceClone the source code from the Github’s repository:git clone https://github.com/hallaj/inupypi.gitBuilding the application:python setup.py developRunning the applicationInupypi can be run using the usual apache mod_wsgi setup as well as stand alone mode.As Standalone WSGI Server:inupypi_server -H <INSERT HOSTNAME> -p <INSERT PORT> -t <HTPASSWD FILE> <PATH TO REPOSITORY>Apache mod_wsgiTo run using apache mod_wsgi, create the following file and save it as inupypi.wsgi:#!/usr/bin/env python
# -*- coding: utf8 -*-

from inupypi import create_app

config = {'INUPYPI_REPO': '/PATH/TO/REPOSITORY'}
application = create_app(**config})Add the following Apache configuration to use the above defined wsgi file:<VirtualHost *:80>
    ServerName      SERVER_NAME

    WSGIScriptAlias / /PATH/TO/inupypi.wsgi
    WSGIDaemonProcess inupypi user=APACHE_USER group=APACHE_GROUP home=/PATH/TO/INUPYPI python-path=/PATH/TO/PYTHON/SITE-PACKAGES/WHERE/INUPYPI/IS/INSTALLED

    <Location />
        WSGIProcessGroup inupypi
        WSGIPassAuthorization On
    </Location>
</VirtualHost>FAQ: Why another pypiserver application ?We could not find another pypiserver that supported multiple repositories.We wanted to have templates with our pypi server so that formatting can be easily done.We had a few ideas where we wanted to bring our pypi server that were not compatible or accepted by one of the pypi server implementations.TODOCreate automated processes to generate all of the steps above to make the process less manual.Auto resolving and updating of package versions.TestsTo run the tests:sh
  python setup.py test
Package: invade
InvadeInvade is a Python 3 library for interacting with Windows processes. Common uses: software security and malware research, reverse engineering, and PoCs.https://github.com/cgio/invadehttps://pypi.org/project/invadeThere are four classes in main.py:Me:for operating environment infoScout:for process discoveryTarget:for target process infoTool:for main operationCommon use case overview:Create an instance of Me and check the operating environment for compatibility.Use Scout to get a list of active processes and the desired PID (process identifier).Instantiate Target using the PID obtained by Scout.Check Target instance properties for information about the target process.Interact with the target process using Tool methods.Another common use case is Invade's relatively fast byte pattern search with wildcard support. Operation is similar toIDA's"sequence of bytes" search. Use Tool.search_file_pattern() to search through a file on disk.Tool.memory_read_pointers() is also useful. With it, you can read through a series of dynamically allocated memory pointers in another process. The method accepts a string containing a start address and relative pointers with common arithmetic operators.Refer to main.py for additional information and usage instructions.Refer to RELEASE.md for release notes.InstallationPython 3.6+ is requiredpip install invadeInstall Keystone for Python. SeePython module for Windows - Binaries.Install Capstone for Python. SeePython module for Windows - Binaries.FilesInside /invade:main.py:contains all main code and classeswinapi.py:contains Windows API codeversion.py:contains version informationExample Projectsinvade_debug_32: Windows x86 32-bit non-attaching debug toolinvade_keepass: KeePass password exfiltrationAuthorsChad Gosselin (https://github.com/cgio)CreditsThank you to the following projects:Keystone: assembler frameworkCapstone: disassembler frameworkCuckoo Sandbox: malware analysis frameworkpefile: PE file frameworkLicenseThis project is licensed under the MIT License. SeeLICENSE.mdfor details. This project is for educational purposes only. Use at your own risk.
Package: invaderclone
Invader CloneProject DescriptionInvader Clone is a ridiculously configurable clone of Space Invaders written in Python. Just about every game setting is swappable using the many available command-line arguments.If you really wish, you can even create your own custom level using the API.Documentation that will help you do all of this is on its way. While you wait, here's the condensed version of the project's usage!InstallThere are two planned options for the installation of Invader Clone. You can install the game either by using pip, or by downloading a launcher for your OS in the Releases section on GitHub.PipTo install using pip, use the following command:
ipip install invadercloneIf your system package manager manages your python packages, you can instead use the following command (PLEASE READ THE WARNING BELOW***):pip install invaderclone --break-system-packages***It's probably okay if you do this, but you should probably install python pygame using your system package manager BEFORE installing Invader Clone using this method.LauncherYou can either build the launcher from source, or you can download the latest version from GitHub Releases.There is a version available for Windows and Linux. A Mac version may or may not come in the future. I haven't quite figured out how I'd do that.You can also find the Game's page on Itch.io. If you like the project, please make a donation through the Itch.io storefront! I won't buy a cup of coffee with it, I promise! I will probably put it towards gas in California.UsageIf you've installed the game through Pip, you can typeinvadercloneinto the terminal to run it.If you downloaded a launcher, double click on the executable file launch it. You will need an internet connection the first time you run this, because the launcher will try to set up a virtual environment in you game directory, and it will install pygame as well.Running the game without any arguments will simply run the game. To see the vast bounty of switches and options you can use to modify your copy of the game, you can typeinvaderclone --helpinto the command line.ThemeingTo learn how to theme your game in-depth, read the CREATING_THEMES.md file that can be found in this repository.In summary, you can place your theme in the config directory chosen for your OS (~/.config/invaderclone on Linux, C:\users\YOU\Documents\invaderclone)Custom LevelsDocumentation will be written on creating custom levels, but it can be done! A custom level can be placed in your config directory (see above). Name your custom level levelN.py, where N is a postive integer that is not 0 (00 probably works).In it, you must define a class that inherits from invaderclone.Scene, or it must inherit from a class that inherits from invaderclone.Scene that I will talk about in the Documentation to come. The class MUST BE NAMED LevelN, where N is the same number you named the script. There are no limits, if you know pygame, you can do anything you want.If you need help creating your Scene, study the workings of the game in this repo.
Package: inVAE
inVAEinVAE is a conditionally invariant variational autoencoder that identifies both spurious (distractors) and invariant features.
It leverages domain variability to learn conditionally invariant representations. We show that inVAE captures biological variations in single-cell datasets obtained from diverse conditions and labs.
inVAE incorporates biological covariates and mechanisms such as disease states, to learn an invariant data representation. This improves cell classification accuracy significantly.InstallationPyPI onlypip install invaeDevelopment Version (latest version on github)git clone https://github.com/theislab/inVAE.gitpip install .ExampleIntegration of Human Lung Cell Atlas using both healthy and disease samplesUsageLoad the data:adata = sc.read(path/to/data)Optional - Split the data into train, val, test (in supervised case for training classifier as well)Initialize the model, either Factorized or Non-Factorized:from inVAE import FinVAE, NFinVAE`

inv_covar_keys = {
    'cont': [],
    'cat': ['cell_type', 'donor'] #set to the keys in the adata
}

spur_covar_keys = {
    'cont': [],
    'cat': ['site'] #set to the keys in the adata
}

model = FinVAE(
    adata = adata_train,
    layer = 'counts', # The layer where the raw counts are stored in adata (None for adata.X: default)
    inv_covar_keys = inv_covar_keys,
    spur_covar_keys = spur_covar_keys
)ormodel = NFinVAE(
    adata = adata_train,
    layer = 'counts', # The layer where the raw counts are stored in adata (None for adata.X: default)
    inv_covar_keys = inv_covar_keys,
    spur_covar_keys = spur_covar_keys
)Train the generative model:model.train(n_epochs=500, lr_train=0.001, weight_decay=0.0001)Get the latent representation:latent = model.get_latent_representation(adata)Optional - Train the classifer (for cell types):model.train_classifier(
    adata_val,
    batch_key = 'batch',
    label_key = 'cell_type',
)Optional - Predict cell types:pred_test = model.predict(adata_test, dataset_type='test')Optional - Saving and loading model:model.save('./checkpoints/path.pt')
model.load('./checkpoints/path.pt')
```<br/>

## Dependencies

* scanpy==1.9.3
* torch==2.0.1
* tensorboard==2.13.0
* anndata==0.8.0


## Citation

[H. Aliee, F. Kapl, S. Hediyeh-Zadeh, F. J. Theis, Conditionally Invariant Representation Learning for Disentangling Cellular Heterogeneity, 2023](https://arxiv.org/abs/2307.00558)
Package: invalid
invalidA small Python library and wrapper aroundpickto help remove the boilerplate around validating and processing command line input.InstallationpipinstallinvalidUsage>>>frominvalidimportpromptPrimitives>>>age_prompt=prompt.Int("age")>>>age_prompt.prompt()Enter age: s
Invalid age 's'
Enter age: 2828Lists>>>fruit_prompt=prompt.List(..."fruit",...["apple","banana","orange"])>>>fruit_prompt.prompt()Enter fruit:
-> apple
   banana
   orange'apple'ID to name mapping>>>fruit_prompt=prompt.List(..."fruit",...{..."A crunchy apple":"apple",..."A sweet banana":"banana",..."A juicy orange":"orange"...}...)>>>fruit_prompt.prompt()Enter fruit:
-> A crunchy apple
   A sweet banana
   A juicy orange'apple'Custom validation>>>postcode_prompt=prompt.Text(..."postcode",...validate=lambdatext:len(text)<=5andtext.isnumeric()...)Enter postcode: 392838
Invalid postcode '392838'
Enter postcode: 0773'0773'Forms>>>form=prompt.Form({..."name":prompt.Text("your full name"),..."dob":prompt.Text("your date of birth"),..."number":prompt.Text(..."your favourite number between 1 - 10",...validate=lambdanum:1<=num<=10...)...})>>>form.execute()Enter your full name: John Doe
Enter your date of birth: 2 July 1987
Enter your favourite number between 1 - 10: 3{'name':'John Doe','date':'1987-07-02','number':3}
Package: invalidroutesreporter
This script is intended to be used as anExaBGPprocess to elaborate and report/log invalid routes that have been tagged with meaningful dedicated BGP communities by route servers.Invalid routes are those routes that, for some reason, didn’t pass the route server’s validation process (invalid/private ASNs in the AS_PATH, bogon prefixes, invalid NEXT_HOP, IRRDBs data mismatch, …). Route servers, instead of discarding them, can keep these routes and tag them with a BGP community that describes the reason for which they have been considered as invalid.A session with an ExaBGP-based route collector can be used to announce these invalid routes to this script, that finally processes them, extracts the reject reason and uses this information to log a record or to send an email alert to the involved networks.If deployed in conjunction withARouteServer, the“tag” reject policy optioncan be used to easily setup the route server to work together with this script.For more information:https://invalidroutesreporter.readthedocs.ioAuthorPier Carlo Chiodi -https://pierky.comBlog:https://blog.pierky.comTwitter:@pierkyChange logv0.2.0New:--rejected-route-announced-by-patternargument, to track a BGP community set with the peer that actually announced the invalid route.New:--peer-asn-onlyoption, to send alerts only to the peers that announced invalid routes.v0.1.0First release as a standalone repository.New: make thereject reason BGP communityoptional and track also routes tagged with areject BGP communityonly.New: optional external file containing the reason-code/description matrix.Fix: extended BGP communities processing.Improvement:min_waitandmax_waittimers handling.
Package: invalid-scraper
invalid-scraperIterate through a list of Cisco IOS routers (invalid_scraper/data/hosts.yml)
and find RPKI Invalid routes learnt from neighbors.Usageusage: invalid-scraper [-h] [--domain DOMAIN] [--username USERNAME]

optional arguments:
  -h, --help            show this help message and exit
  --domain DOMAIN, -d DOMAIN
  --username USERNAME, -u USERNAME
Package: invarpy
invarpy package v1.3.0Package that includes several methods to compute statistical translation non-invariance of primarly, but not limitted to, scalar
cosmological fields.Updates on v1.3.0New method called invarpy.py that calculates the first kind estimator and its bias
through pbc configuration space method for a three-dimensional field.Older versions updatesUpdates on v1.2.1All 1D methods are working;Removed unnecessary package functools;Now every method takes the same input. This means that for a configuration space routine, input
field is the field in configuration space, whereas for a Fourier space routine, input field is
the Fourier transform of the field in configuration space. For the bias routines, input must be
the field power spectrum not-normalized. The common.py method computes the power spectrum without
normalizing it. Normalization happens inside the routines of nopbc_estimators or pbc_estimators
methods.Minor Bug fixes on v1.2.0Fixed sigma estimator if statement on nopbc_estimators method;nopbc_estimators method is working correctly.Major Bug fixes on v1.1.2Fixed configuration space on pbc_estimators method normalization factor for the estimator bias;Fourier space and configuration space for pbc_estimator.py is working correctly.Minor Bug fixes on v1.1.1Fixed bug of 'unexpected keyword argument estimator_kind' on sigma_which_diagonal routine of pbc_estimator.py method.Major Bug fixes on v1.1.0Fixed second and first kind estimator bias in pbc_estimators.py method.Fixed second kind estimator bias in pbc_estimators.py method;Fixed bugs on common.py.