Saravanan666/pypi-org huggingface dataset:
Package: py-application-framework
py-application-frameworkThis is a simple and lightweight application framework library for python.Features:...Python CompatibilityThis library is compatible and tested with the following Python versions:Python 3.7Python 3.8Python 3.9Python 3.10Python 3.11Python 3.12Installation:$pipinstallpy-application-frameworkExample - xxx# ...Documentation:You can find the latest documentation atreadthedocs.Contribution:If you want to contribute to the code base, create a pull request on the develop branch.We follow thegit flowbranching model.Release Notes1.0.0-alpha.1(2024-02-xx)Initial alpha release.Added xxx...Basic Documentation: An initial set of documentation is provided, giving users an introduction to the library.License: Released under the GPL 3 license.
Package: pyapplier
README.scrobbler.log (Rockbox offline last.fm scrobling format) submiter.Features.scrobbler.log submitingmultiple accounts supportRequirenmentspython3python-pylastpython-setuptoolspython-pyamlHow toSubmitpyapplier.py -f /path/to/.scrobbler.logSome regions may have sync lag for last.fm website, so you may add-wflag for wait countdown.Add-yflag to assumeYes. In case of multiple saved accounts add-y USERNAMEAccounts mangmentCredetial stores in~/.config/pyapplier/saved_credslist saved accounts:pyapplier.py creds listchange account password:pyapplier.py creds edit USERNAMEdelete account:pyapplier.py del USERNAMEadd account:pyapplier.py add USERNAME
Package: pyapply
PyApplyPyApply is a command-line interface (CLI) tool designed to automate coverletter creation, significantly reducing the time required to perform them.
Heres a  Walkthrough on Medium and Youtube[!NOTE]
Currently, this app only works for ASU Student jobs.FeaturesCover Letter Generation: PyApply can generate cover letters based on provided job descriptions and user details.Preset and Custom Themes: Choose from predefined themes or use your own custom theme for the cover letters.User Profile Management: Set user details globally or for specific tasks using JSON files.InstallationpipinstallpyapplyUsage[!NOTE]
if the below commands dont work directly, try addingpython -mbefore every command listed below.
Example:python -m pyapply aboutAboutpyapplyaboutProfile SetupTo set User Profilepyapplyset_user<path/to/save/asujobs>To set context information for coverletterspyapplyset_resume<path/of/resume.txt>Generate cover letterspyapplylistenCoverletters will be generated automatically as soon as the clipboard values change.PerformancePyApply can convert a process that typically takes 5-10 minutes into a task that takes just 30 seconds.LicenseMIT
Package: pyApp-Messaging
Let use handle the boring stuff!The messaging extension provides an abstract interface to various messaging
implementations. This lets your application seamlessly migrate from AMQP to SQS
without any changes to your main application code.NoteThe primary focus of work is on asyncio based queues.InstallationInstall usingpiporpipenv:# Using pip
pip install pyapp-Messaging

# Using pipenv
pipenv install pyapp-MessagingUsageThis library is easiest used with the injection framework eg:from pyapp.injection import inject, Args
from pyapp_ext.messaging import MessageReceiver

@inject
def my_function(queue: MessageReceiver = Args(name="job_queue")):
    queue.send_message("Do job A")or usingasyncio:from pyapp.injection import inject, Args
from pyapp_ext.messaging.asyncio import MessageSender

@inject
async def my_function(sender: MessageSender = Args(name="job_queue")):
    await sender.send("Do job A")API
Package: pyApp-Redis
Let us handle the boring stuff!This extension provides aRedisclient factory to allow configuration to be
configured via pyApp settings.The extension also provides checks to confirm the settings are correct and that
the application is able to connect to the redis instance.It is strongly recommended to install thehirediscompanion package to improve
the performance of the redis client.InstallationInstall usingpip:pip install pyapp-redisInstall usingpipenv:pipenv install pyapp-redisAdd theREDISblock into your runtime settings file:REDIS = {
    "default": {
        "url": "redis://user:pass@host:port/1",
    },
}NoteThe URL is a defined by Redis client see thedocumentation.
In addition to the url any argument that can be provided toRedis.from_urlcan be provided.UsageThe following example creates aRedisclient instance:from pyapp_ext.redis import get_client

# Get connection
redis = get_client()

redis.set("foo")APIpyapp_ext.redis.get_client(default: str = None) -> RedisGet namedRedisclient instance
Package: pyapprox
PyApproxDocumentationOnline documentation can be found atPyApproxDescriptionPyApprox provides flexible and efficient tools for high-dimensional approximation and uncertainty quantification. PyApprox implements methods addressing various issues surrounding high-dimensional parameter spaces and limited evaluations of expensive simulation models with the goal of facilitating simulation-aided knowledge discovery, prediction and design. Tools are provided for: (1) building surrogates using polynomial chaos expansions using least squares, compressive sensing and interpolation; (2) sparse grid interpolation and quadrature; (3) low-rank tensor-decompositions; (4) multi-fidelity approximation and sampling; (5) large-scale Bayesian inference; (6) numerical solvers for canonical ordinary and partial differential equations useful for demonstration purposes; (7) compressive sensing solvers; and (8) visualization. The code is intended to as a python toolbox but provides c++ code with Python interfaces to computationally expensive algorithms to increase performance.Practical ApplicationThe software provides foundational numerical algorithms for approximation of multivariate functions and quantifying uncertainty in numerical models. The software is primarily used to build surrogates of generic functions. Often such functions are quantities of interest of numerical simulation models of, for example, sea-level change due to ice-sheet evolution, or ground-water flow. Once surrogates are generated they are used to undertake sensitivity analysis to identity important model parameters and to compute statistics of the variable model output caused by sources of uncertainty.Method of SolutionThe tools provided are based on mathematical algorithms for: (1) building surrogates using polynomial chaos expansions using least squares, compressive sensing and interpolation; (2) sparse grid interpolation and quadrature; (3) low-rank tensor-decompositions; (4) multi-fidelity approximation and sampling; (5) large-scale Bayesian inference; (6) numerical solvers for canonical ordinary and partial differential equations useful for demonstration purposes; and (7) compressive sensing solvers. The modularity of the code structure and function API are intended to facilitate flexible use and extension of the available tools. Numerous functions are provided to facilitate testing and benchmarking of algorithms.AcknowledgementsThis research was developed with funding from the Defense Advanced Research Projects Agency (DARPA). The views, opinions and/or findings expressed are those of the author and should not be interpreted as representing the official views or policies of the Department of Defense or the U.S. Government.
Package: pyapproxmc
pyapproxmc: bindings to the ApproxMC model counterThis directory provides Python bindings to ApproxMC on the C++ level,
i.e. when importing pyapproxmc, the ApproxMC counter becomes part of the
Python process itself.Installingpip install pyapproxmcCompilingIf you don't want to use the pip package, you can compile it:apt-get install python-dev
cd python
git clone https://github.com/msoos/cryptominisat
git clone https://github.com/meelgroup/arjun
cd ..
python -m build

You will then find the files under "dist/".Usageimport pyapproxmc
c = pyapproxmc.Counter()
c.add_clause([1,2,3])
c.add_clause([3,20])
count = c.count()
print("Approximate count is: %d*2**%d" % (count[0], count[1]))The above will print thatApproximate count is: 88*2**13. Since the largest variable in the clauses was 20, the system contained 220 (i.e. 1048576) potential models. However, some of these models were prohibited by the two clauses, and so only approximately 88*213 (i.e. 720896) models remained.If you want to count over a projection set, you need to callcount(projection_set), for example:import pyapproxmc
c = pyapproxmc.Counter()
c.add_clause([1,2,3])
c.add_clause([3,20])
count = c.count(range(1,10))
print("Approximate count is: %d*2**%d" % (count[0], count[1]))This now printsApproximate count is: 56*2**3, which corresponds to the approximate count of models, projected over variables 1..10.Counter ObjectYou can give the following arguments toCounter:seed-- sets the random seedverbosity-- sets the verbosity of the system (default = 0)epsilon-- Tolerance parameter, i.e. sets how approximate the returned count is. Default = 0.8delta-- Confidence parameter, i.e. sets how probabilistically correct the returned count is. Default = 0.20
Package: pyappscan
About the ModuleThis python module is used in conjunction with IBM Appscan Enterprise REST API, and allows anyone to do a multitude of things with simple python code. If you would like something added to the program, you may make a pull request, or request that it be added inthe issues section.Legal DisclaimerCopyright 2022, by the California Institute of Technology. ALL RIGHTS RESERVED. United States Government Sponsorship acknowledged. Any commercial use must be negotiated with the Office of Technology Transfer at the California Institute of Technology.This software may be subject to U.S. export control laws. By accepting this software, the user agrees to comply with all applicable U.S. export laws and regulations. User has the responsibility to obtain export licenses, or other export authority as may be required before exporting such information to foreign countries or providing access to foreign persons.Appscan Version RequirementsYour version of Appscan should be able to support the requisite API calls made by the library. This library is tested with Appscan v9.8.0+, however it is compatible with lower versions (though ymmv).DependenciesPython 3.5 or higherrequestsbeautifulsoup4Can be installed with:pipinstall--userpyappscanHow to UseUse this module by importing the class first, then calling the method you would like to use. It is initiazized with the url to the appscan api, followed by the username, password, featurekey, and ssl cert path (for more information on the feature key, please look at the appscan api docs, which give different options. The default isAppscanEnterpriseUser). Usage:frompyappscanimportcreate_enginemyClass=create_engine('https://route-to-appscan-api.com:443/ase/api',username='user',password='pass',key='AppscanEnterpriseUser',verify='/var/www/mycerts/appscancert.crt')# We can also use an API key to loginmyClass=create_engine('https://route-to-appscan-api.com:443/ase/api',apikey="ac6719683d871e173961ff",secretkey="secret-key",verify='/var/www/mycerts/appscancert.crt')DocumentationCheck theDocumentationfor more information on class methods, return types, and API docs.
Package: pyappsflyer
PyAppsFlyerUnofficial python wrapper for AppsFlyer API.https://www.appsflyer.com/For working with this application you need to receive API_KEY in your
personal account on website.Getting performance data reportfrompyappsflyer.apiimportPerformanceReportreport=PerformanceReport(api_key='your_api_key',application_name="your_application_name",)report.get_report()Default report is partners report. If you wish to change and receive another:frompyappsflyer.apiimportPerformanceReportreport=PerformanceReport(api_key='your_api_key',application_name="your_application_name",)report.get_report(api_report_name='daily_report')If report is not listed in available report you will be notified with an Exception.
All possible report are listed on application site. Please refer to them.Report will be returned in python dict() type, so they can be easily transformed into JSON.All method parameters:from_date - from what date to begin, date format - YYYY-MM-DDto_date - at what date to end, date format - YYYY-MM-DDtimezone - timezone for api request, default - Europe/Moscowapi_report_name - name of the performance report according to api documentation, stringIf you want to receive all possible reports, use another method.frompyappsflyer.apiimportPerformanceReportreport=PerformanceReport(api_key='your_api_key',application_name="your_application_name",)report.get_reports()Reports will return in python list() type, so they can be easily transformed into JSON.Also you could create an .env file with parameters shown below. The file must be near src
folder, or it would not be read. Do not put env file inside src folder.Upon application start this file will be loaded and all additional parameters will be used.APP_FLYER_HOST  - host of an AppsFlyer API.APP_FLYER_API_KEY = AppsFlyer API KEY.DEFAULT_DAYS_NUMBER = Number of days for timedelta.
Application will try to receive all info for previous days, shown here.DEFAULT_TIMEZONE - default timezone is Europe/Moscow, could be changed. From API docs.DEFAULT_CSV_DELIMETER - default csv files delimeter. From API docs.DEFAULT_CSV_QUOTECHAR - default quotechar delimeter. From API docs.DEFAULT_CSV_ENCODING - default encoding is UTF-8-SIG. From API docs.If you want to receive other variants of reports there two classes.
RawDataReport and TargetingValidationRulesReport
These classes could be initialized as shown above.
Package: pyApp-SMTP
Let us handle the boring stuff!This extension provides anSMTPclient object configured via pyApp settings.InstallationInstall usingpip:pip install pyApp-SMTPInstall usingpipenv:pip install pyApp-SMTPAddpae.smtpinto theEXTlist in your applicationsdefault_settings.py.Add theSMTPblock into your runtime settings file:SMTP = {
    "default": {
        "host": "localhost",
    }
}NoteIn addition to thehostany argument that can be provided tosmtplib.SMTPcan be
provided.UsageThe following example creates an SMTP client instance:from pae.smtp import get_client

smtp = get_client()APIpae.smtp.get_client() -> SMTPGet namedSMTPinstance.
Package: pyApp-SQLAlchemy
Let us handle the boring stuff!This extension provides aConnectionandSessionfactory for SQLAlchemy to
allow database connections to be configured via pyApp settings.Engineinstances are created from a singleton factory to ensure that
connection pooling is utilised.The extension also provides checks to confirm the settings are correct and
that the application is able to connect to the database host.InstallationInstall usingpip:pip install pyapp-sqlalchemyInstall usingpipenv:pipenv install pyapp-sqlalchemyAddpyapp_ext.sqlalchemyinto theEXTlist in your applicationsdefault_settings.py.Add theDATABASE_ENGINESblock into your runtime settings file:DATABASE_ENGINES = {
    "default": {
        "url": "postgres://user:pass@host:port/database",
    },
}NoteThe URI is a defined by SQLAlchemy see thedocumentation. In addition to
the url any argument that can be provided tosqlalchemy.engines.create_enginecan be
provided.UsageThe following example creates bothConnectionandSessioninstances:from pyapp_ext.sqlalchemy import get_connection, get_session

# Get connection from default connection pool
cnn = get_connection()

# Get connection from an alternate pool
session = get_session("Alternate")APIpyapp_ext.sqlalchemy.get_engine(default: str = None) -> EngineGet namedEngineinstance (singleton)pyapp_ext.sqlalchemy.get_connection(default: str = None) -> ConnectionGet namedConnectioninstance.pyapp_ext.sqlalchemy.get_raw_connection(default: str = None)Get namedrawconnection, this is the underlying Python DBAPI object.pyapp_ext.sqlalchemy.get_session(default: str = None) -> SessionGet namedSessioninstance.
Package: pyapputil
pyapputilPython module to simplify building CLI applications. Includes simple helpers for
building an app, validating arguments, configfiles/default values, logging,
global exception catching, privilege escalation, signal handling,
time/timezones, multithreading...Python 2 and 3 compatible.appframeworkThis wrapper takes care of signal handling, uncaught exceptions, exit codes, and a host of other
things so you don't have to. It integrates with appconfig, argutil to provide argument parsing with config file support,
overidable default values, and user friendly help, plus typeutil to provide easy, strong argument
validation while maintaining duck typing.frompyapputil.appframeworkimportPythonAppfrompyapputil.appconfigimportappconfigfrompyapputil.argutilimportArgumentParserfrompyapputil.typeutilimportValidateAndDefault,OptionalValueType,StrType@ValidateAndDefault({# "arg_name" : (arg_type, arg_default)"arg1":(OptionalValueType(StrType(allowEmpty=False)),appconfig["arg1"]),"arg2":(float,0),})defmain(arg1,arg2):passif__name__=='__main__':parser=ArgumentParser(description="My cool commandline app")parser.add_argument("-a","--arg1",type=StrType(allowEmpty=False),default=appconfig["arg1"],help="the first argument")parser.add_argument("-b","--arg2",type=float,help="the second argument")args=parser.parse_args_to_dict()app=PythonApp(main,args)app.Run(**args)appconfigThis module presents configuration values combined from defaults, user config,
and environment variables.To get a configuration variable namedsome_value:frompyapputil.appconfigimportappconfigappconfig["some_value"]The default values are stored inappdefaults.pyin the application's
root directory. This is a pure python file that gets imported, so you it can be
anything from a list of variables/values to any arbitrary code you need to set
up your default values.The user can optionally provide auserconfig.ymlfile to override
the defaults. This is a text YAML file that gets loaded after appdefaults.py,
and any values in this file will override values from appdefautls.
If the user wants to override a default named some_var, they can simply add an
entry to userconfig.yml like this:
some_value: 123The user can optionally export environment variables to override the defaults or
user config. The prefix used for environment variables is set in appdefaults.py.
If the prefix is set to  "MYAPP_" and the user wan't to override a config var
named some_value, they could override it with an environment varible like this:export MYAPP_SOME_VALUE=123argutilThis is a forked version of python's argparse, that is integrated with appconfig
so that command line arguments can automatically set default values from
appconfig, and the help display will show the default value as well as the name
of the ENV variable that can be used to override it.typeutilCollection of type validators that can be used with argparse/argutil, and
decorators and util functions for using the same validators on functionsexceptutillogutilshellutilthreadutil
Package: pyapr
pyaprDocumentation can be foundhere.Content-adaptive storage and processing of large volumetric microscopy data using the Adaptive Particle Representation (APR).The APR is an adaptive image representation designed primarily for large 3D fluorescence microscopy datasets. By replacing pixels with particles positioned according to the image content, it enables orders-of-magnitude compression of sparse image data while maintaining image quality. However, unlike most compression formats, the APR can be used directly in a wide range of processing tasks - even on the GPU!PixelsAPRUniform samplingAdaptive samplingimage source,illustration sourceFor more detailed information about the APR and its use, see:Adaptive particle representation of fluorescence microscopy images(nature communications)Parallel Discrete Convolutions on Adaptive Particle Representations of Images(IEEE Transactions on Image Processing)pyapris built on top of the C++ libraryLibAPRusingpybind11.Quick start guideConvert images to APR using minimal amounts of code (seeget_apr_demoandget_apr_interactive_demofor additional options).importpyaprfromskimageimportio# read image into numpy arrayimg=io.imread('my_image.tif')# convert to APR using default settingsapr,parts=pyapr.converter.get_apr(img)# write APR to filepyapr.io.write('my_image.apr',apr,parts)To return to the pixel representation:# reconstruct pixel imageimg=pyapr.reconstruction.reconstruct_constant(apr,parts)Inspect APRs using our makeshift image viewers (seenapari-apr-viewerfor less experimental visualization options).# read APR from fileapr,parts=pyapr.io.read('my_image.apr')# launch viewerpyapr.viewer.parts_viewer(apr,parts)TheView Leveltoggle allows you to see the adaptation (brighter = higher resolution).Or view the result in 3D using APR-native maximum intensity projection raycast (cpu).# launch raycast viewerpyapr.viewer.raycast_viewer(apr,parts)See thedemo scriptsfor more examples.InstallationFor Windows 10, OSX, and Linux direct installation with OpenMP support should work viapip:pip install pyaprNote: Due to the use of OpenMP, it is encouraged to install as part of a virtualenv.SeeINSTALLfor manual build instructions.Licensepyapris distributed under the terms of theApache Software License 2.0.IssuesIf you encounter any problems, pleasefile an issuewith a short description.Contact usIf you have a project or algorithm in which you would like to try using the APR, don't hesitate to get
in touch with us. We would be happy to assist you!
Package: pyaprilaire
pyaprilairepyaprilaire is a library to interact with Aprilaire thermostats.Compatibilityaprilaire-ha is generally compatible with AprilaireHome Automation8800-series andZone Control6000-series thermostats. However, due to the number of physical models, it has not been tested on all models.PrerequisitesIn order to connect to the thermostat, you will need to enable automation mode. This involves going into the Contractor Menu on your thermostat and changing the Connection Type to Automation. Please look up the instructions for your model, as this can vary between models.DevelopmentMock serverDuring development, it is necessary to connect to a thermostat, but this can be problematic as a thermostat only allows a single connection at a time. There is a mock server that can be run to expose a local server for development that emulates a thermostat.python -m pyaprilaire.mock_serverThe port can be specified with-p PORT_NUMBER. The default port is 7001.Caution regarding device limitationsDue to limitations of the thermostats, only one home automation connection to a device is permitted at one time (the Aprilaire app is not included in this limitation as it uses a separate protocol). Attempting to connecting multiple times to the same thermostat simultaneously can cause various issues, including the thermostat becoming unresponsive and shutting down. If this does occur, power cycling the thermostat should restore functionality.The socket that is exposed by the thermostat can be unreliable in general. In some cases, it can silently drop the connection or otherwise stop responding. The integration handles this by quietly disconnecting and reconnecting every hour, which generally improves stability. In some cases, however, there may be periods where the change of state (COS) packets aren't received, potentially causing stale data to be shown until the connection is reset.If this happens to you frequently and you are able to capture the packets at the time via Wireshark showing the state of the socket, this data would be valuable to share.