Saravanan666/pypi-org huggingface dataset:
Package: lo99ing
Python logging, configured the way I like it.Logger BehaviorDefault behavior when usinglo99ing:logs to stderr onlylog level (of each individual logger) defaults to:WARNING for “installed” modules (site-packages and dist-packages)INFO for “local” modules (in user’s local dev env)message format:%(asctime)s:%(levelname)s:%(name)s:%(message)sMessage Logging Behaviorlogger.exception()automatically extracts and prints exception attributesWhen logging an exception object, automatically adds exception type:logger.error('exceptionraised: %s', KeyError(0))  # prints: 'exception raised: KeyError--0'if logging messages fails formatting, also logs the location of the problematic call:logger.info('forgotthe percent sign', 555)  # includes: 'Logged from /path/to/file.py:LINENUM'Usage and Other FeaturesGet a logger usingget_logger(logger_name,...)Get a logger with current module’s (or script’s) basename using:get_logger(__file__)Log to a file, usingenable_file(filename)Create an “independent” (i.e.,propagate=False) file-logger, usingget_file_logger(filename)Disable/re-enable logging to stderr (on root logger), usingenable_stderr()anddisable_stderr()Change logging clock “converter” to UTC usinguse_utc()Change logging clock to a custom clock usinguse_clock(clock)This is useful when “replaying past events”, and you want timestamps to appear accordinglylog-level overrides: set and reset (“undo”) log levels using overrides:logger.set_log_level_override(level)orset_log_level_override(name, level),reset usingset_log_level_override(name, None)Create a logger-like object, which adds a prefix to messages it logs, usinglogger.prefixed('PREFIX:')Log a “trace” message with current filename and line number, usinglogger.TRACE()useful for “tracing” / “printf-debugging”Usage NotesShould avoid usinglogging.getLogger()directly.  Instead, uselo99ing.get_logger()Should not uselogger.setLevel()directly.  Instead, useget_logger(...,level=LEVEL,...)orset_log_level_override()InstallationUsing pip:pip install lo99ing
Package: loadanim
Loadingloading.py is an extremely minimal python package that allows for you to get those cool animated loading
texts you see in terminal applicationstutorialthis package doesn't require a vast amount of explaining to learn how to use it. Here's an example
python script:fromloadanim.loadanimimportLoadingif__name__=='__main__':load=Loading()#creates a load instanceload.start("loading stuff ")#starts displaying the loading terminal to the terminaltime.sleep(5)#wait 5 secondsload.stop()#stop displaying the loading animation to the terminalloading.py uses multiprocessing to allow you to load and process chunks of data whilst showing this cool animation to the user.
Package: load-atoms
[!WARNING]
This project is under active development. Until version 1.0.0 is released, breaking changes to the API may occur with no notice.load-atomsis a Python package forLoadingOpenAccessDatasets forAtomisticMaterialsScience (LOAD-AtoMS).
See thedocumentationfor more information.load-atomsis maintained by me, John Gardner (GitHub-website), as part of my PhD research activities within theDeringer Group.Installationpip install load-atomsUsage>>>fromload_atomsimportload_dataset>>>dataset=load_dataset("C-GAP-17")╭─────────────────────────── C-GAP-17 ────────────────────────────╮│                                                                 ││  ✓  Downloading C-GAP-17.extxyz ━━━━━━━━━━━━━━━━━━━━ 100% 00:00 ││  ✓  Reading C-GAP-17.extxyz     ━━━━━━━━━━━━━━━━━━━━ 100% 00:01 ││  ✓  Caching to disk             ━━━━━━━━━━━━━━━━━━━━ 100% 00:00 ││                                                                 ││ The C-GAP-17 dataset is covered by the CC BY-NC-SA 4.0 license. ││  Please cite the C-GAP-17 dataset if you use it in your work.   ││     For more information about the C-GAP-17 dataset, visit      ││                       load-atoms/C-GAP-17                       │╰─────────────────────────────────────────────────────────────────╯>>> print(dataset)

C-GAP-17:
    structures: 4,530
    atoms: 284,965
    species:
        C: 100.00%
    properties:
        per atom: (force)
        per structure: (config_type, detailed_ct, energy, split)DevelopmentPlease see thecontributing guidelinesfor information on how to contribute to the project.
Package: loadbalancer-interface
loadbalancerInterface Protocol API LibraryThis library provides an API for requesting and providing load balancers or
ingress endpoints from one charm to another. It can be used in either charms
written in the newerOperator Frameworkor older charms still using thecharms.reactive Framework.Installation / SetupInclude this library as a dependency for your charm, either inrequirements.txtfor Operator Framework charms, orwheelhouse.txtfor
reactive charms:loadbalancer_interfaceUsageRequesting Load BalancersRequesting a load balancer from a provider is done via theLBProviderclass.
The general pattern for using the class is:Wait for the provider to become availableGet aRequestobject via theget_request(name)methodSet the appropriate fields on the request objectSend theRequestvia thesend_request(request)methodWait for theResponseto be provided (or updated)Get theResponseobject via either theget_response(name)method or
via thenew_responsespropertyConfirm that the request was successful and use the provided LB's addressAcknowledge theResponseviaack_response(response)There are examples in the repo for how to do this inan operator charmor ina reactive charm.Providing Load BalancersProviding a load balancer to consumers is done via theLBConsumersclass.  The
general pattern for using the class is:Wait for new or updated requests to come inIterate over each request object in thenew_requestspropertyCreate a load balancer according to the request's fieldsSet the appropriate fields on the request'sresponseobjectSend the request's response via thesend_response(request)methodThere are examples in the repo for how to do this inan operator charmor ina reactive charm.API ReferenceSee theAPI docsfor detailed reference on the API.Test CharmsTo ease testing of charms using this interface, this library provides test charms
which can be used with the pytest-operator plugin based integration test to
serve as a basic counterpart to the charm providing or requiring this interface.The charms are accessed via anlb_charmsfixture, which is session scoped.
The fixture provides an object with attributes for each of theexample
charmsavailable in the repo. (The attribute names will be the charm names
with dashes replaced with underscores.) For example:asyncdeftest_build_and_deploy(ops_test,lb_charms):my_charm=awaitops_test.build_charm(".")lb_provider=awaitops_test.build_charm(lb_charms.lb_provider)awaitops_test.model.deploy(my_charm)awaitops_test.model.deploy(lb_provider)awaitops_test.model.add_relation("my-charm","lb-provider")
Package: load-config
Load ConfigHelper functions for loading configuration files. Useful to test/debug using config parameters.Custom functions currently supported:LoadAWS SAM templateLoadAWS SAM configuration fileLoad AWS SAM local Lambdaenvironment variablesLoadDynamoDB local(Docker) configuration templatesWe built this library inHacktto support local development of internal projects andpublic apps in our catalog. Learn more about other open-source libraries onlib.hackt.app.Runtime supportThis is the Python runtime library, compatible with Python3.6+. Currently there isn't support for other runtimes. A Javascript/nodejs version is planned, but unscheduled.Installation and UsageInstall with pip:pip install load-configLoadAWS SAM templatefile:importload_configtemplate=load_config.sam_template()env_vars=template['Resources']['MyFunction']['Environment']['Variables']By default,load_configwill look for SAM templates in./template.yaml. Optionally, specify a different path:template=load_config.sam_template(filepath='my-project/template.yml')DocumentationDocumentation is available in therepository wiki.LicenseThis library is licensed underApache 2.0.Contributor guidePlease check out guidelines in therepository wiki.AcknowledgementsPublished & supported byHackt AppLogos provided byClearbit
Package: loadcsv
loadcsvis a programa and a library to load CSV files to databases and for
converting CSV files to SQL inserrt or update statements.The utility gets the names of the columns from the first row of the CSV file.I wrote this utility because I was tired of doing always small scripts for
doing this kind os loads.By now the utility suport MySQL, PostgresSQL and sqlite, but can be used with
other SQL databases using the utility to generate the SQL statements and sending
them to the database:Usage: loadcsv [options] filename.csv
If no database provided, display SQL to stdout

Options::
  -h, --help            show this help message and exit
  -D DRIVER, --driver=DRIVER
                        database driver mysql, pgsql, sqlite
  -H HOSTNAME, --hostname=HOSTNAME
                        database server hostname,defaults to localhost
  -d DBNAME, --dbname=DBNAME
                        database name (filename on sqlite)
  -u USER, --user=USER  database username
  -p PASSWORD, --password=PASSWORD
                        database password
  -P PORT, --port=PORT  database port
  -t TABLE, --table=TABLE
                        database table to load
  --test                run text, do no commit to the database
  --delimiter=DELIMITER
                        CSV file field delimiter, by default semi-colonhe project code and bugtracker is hosted onBitbucket.InstallUsing pip:pip install loadcsvOs download and usesetuppython setup.py installLinksProject site.Freshmeat project page.Python package index page.
Package: load-distributed-routing
Distributed Load Routing v1.0.5Simulates a network and runs a networking protocol aimed to distribute packet load in order to distribute battery depletion.Installationpipinstallload-distributed-routingPackage Link PyPiReleaseDevelopmentConfiguration FileFieldDescriptionAccepted Valuesnum_nodesNumber of nodes in the network[2, inf)max_connectionsMaximum number of connections a node can have[2, num_nodes)router_ratioPercentage of routers in the network[0.0, 1.0]buffer_sizeNumber of packets the link layer receive buffer can hold at a time[0, inf)battery_weightHigher the battery_weight, the more the path avoids low battery[0.0, inf)retransmission_delayNumber of seconds TCP waits before retransmission[0.0, inf)beautifyDetermines whether the simulation debugs readable information or csv formatted information[0, 1]Runningldrconfig.txt
Package: load-dotenv
load-dotenvEnvironment variables are a great and popular way to configure your application.
Although the number of such variables can be really high in a big application, making
it annoying to manage during development.Common solution for this issue is usage of.envfiles which contain all variables
that should be loaded into your development environment. There are different ways
to do this, for example handypython-dotenvpackage. But it should be executed explicitly in order to work. In my projects
I don't want to addload_dotenv()execution in my code that is running on
production, and I'm too lazy to create customer runners for development only.
Thus, I madeload-dotenvthat can do this for me automatically.Installationpipinstallload-dotenvUsageCreate.envfile in your working directory and put your variables there.
For details about file format, please referpython-dotenv documentation.
Run your application withLOAD_DOTENVvariable set to one oftrue,yesor1.Alternative path to the file can be specified viaLOAD_DOTENV_PATHvariable.
Package: loadenv
loadenvAutomatically load environment variables into structured Python dataLoadenv makes it easy to pull environment variables into your program. It centralizes and hides the
task of loading environment variables and asserting necessary variables are set, while assigning
default values for those that are not required.Loaded variables are cast to python objects based on type annotations and stored as identifiers, not
strings. So typo bugs are easier to catch and names are easier to autocomplete. It does all this
during startup, making bad invocations quit as soon as possible and with a clear error message,
rather than deep in business logic from strange Exceptions.Getting StartedDefine anEnvEnumwhere each member is named exactly as the environment variable you wish to
capture. It should be annotated with the type you would like the member to be. You will have to
assign some value to the member to actually create it. For required environment variable this value
does not matter; values such as()or...are good choices.fromloadenvimportEnvEnum# values are taken from the environment when the class is createdclassSecrets(EnvEnum):USERNAME:str=()USERPASS:str=()USERAPIKEY:str=()# later onrequests.post(prod,headers={"Authorization":f"TOK:{Secrets.USERAPIKEY}"})
Package: load-env-vars-at-startup
load-env-vars-at-startupTo understand themotivationbehind this package, you might want to read aboutfail fast.What this package does is to make sure you are reading all the environment variables at startup.ExampleConsider that you have a folder with the following structure:app/
├── __init__.py
└── main.pyInside ofmain.pyyou have:fromfastapiimportFastAPIapp=FastAPI()@app.get("/")defindex():name=os.environ["APP_NAME"]return{"message":f"Hello,{name}!"}If you run this application, it will run without any problem, but if you forget to set theAPP_NAMEenvironment variable,
you will get an error when you try to access the/endpoint.To avoid this, you can use this package.If you decide to use it, your folder structure will look like this:app/
├── __init__.py
├── main.py
└── config.pyYourconfig.pywill look like this:frompydanticimportBaseSettingsclassSettings(BaseSettings):APP_NAME:strsettings=Settings()And yourmain.pywill look like this:fromfastapiimportFastAPIfromapp.configimportsettingsapp=FastAPI()@app.get("/")defindex():name=settings.APP_NAMEreturn{"message":f"Hello,{name}!"}InstallationYou can installload-env-vars-at-startupviapip:pipinstallload-env-vars-at-startupUsagelevasDIRWhereDIRis the directory of your application.LicenseThis project is licensed under the terms of the MIT license.
Package: loaderr
## LoaderrEver wonder why the solutions you think of in your head never work? Why your ability to write awesome code is limited? Well here it is – you're not using `Loaderr`.With `Loaderr`, you can create simple loading icons to use in your projects. Say you want your program to seem like it's processing something?```from loaderr import *loading("Processing$.$", dots, medium, 5)```It's that simple! With this code, your program will literally halt its progress just to print:```Processing.Processing..Processing...```## TutorialThere are two functions in `Loaderr`.+ `clear_line()`Sets the cursor back so text can be printed over it.+ `loading(string, logo, timing, repeat)`Creates a "loading" thing.+ The `string` is determines what surrounds the loading animation. For example `Loading$$` will create `Loading.` -> `Loading..` -> `Loading...`. The two `$` indicate where the animation is placed. If the string is empty, it replaces the entire string.+ The `logo` is an array that stores the animation. To get the dots, you could do `[".", "..", "..."]`.+ The `timing` is an array the stores the wait times within each animation. For example, `[0.5]` will display the animation every half a second. `[0.1, 0.2]` will display the first frame after `0.1` seconds and the next after `0.2` seconds.+ The `repeat` is the amount of times to loop the animation.## Pre-SetsThere are several pre-defined animations and wait times. These are inside the `loaderr.py` file. For example, `loaderr.table_flip` is `(╯°□°）╯┳━┳` -> `(╯°□°）╯┳━┳` -> `(╯°□°）╯︵┻━┻` -> `(╯°□°）╯︵  ┳━┳`
Package: loadforecast
LoadforecastA package for an easy time series forecasting of an electrical load based on facebook prophet.
It inherits the base of prophet which is additive model where non-linear trends are fit with yearly, weekly,
and daily seasonality, with optional holiday effects. It is robust to missing data and outliers as well.Package is build around child class of original prophet, replacing initial values of attributes by those tuned for
electrical load forecasting using grid search method. Package contains functions that are mainly packing up original
functions to more user-friendly ones.We are sorry for inconvenience but currently it is necessary to installprophetpackage manually as main dependency.
For more information about the installation procedure checkhttps://github.com/facebook/prophetLoadforecast is on PyPI, so you can usepipto install it.pipinstallloadforecastAPI Demo:# Initialize model on pandas.DataFrame containing columns 'DateTime' and 'Load'
m = LoadProphet(df)# Make default one day prediction with sample period of 15 minutes.
forecast = m.prediction()ChangelogChangelog FileLicenseProphet is licensed under theMIT license.
Package: loadguard-runner
LoadGuard RunnerAn agnostic runner for automation of common tasks related to the performance test execution process.Table of ContentsSynopsisUsageInstallationBuildTestsDéveloppementCompatibilityIssuesContributingCreditsResourcesHistoryLicenseSynopsisLoadGuard is a SaaS agnostic solution for automating the process of preparing, executing, collecting and analyzing performance tests.The LoadGuard Runner is an agnostic runner for automation of common tasks related to the performance test execution process..UsageInstallationUsingpippip3installloadguard-runnerUsingsetup.pyClone the repository:gitclonehttps://github.com/loadguard/runnercdrunner
gitcheckoutmain# or any branch, tag or commit...Install dependencies:pythonsetupinstall# or:pipinstall-rrequirements.txtOptional, install dependencies to run unit tests:pipinstall-rrequirements-cicd.txtBuildpython3setup.pybuildTestspython3setup.pytestCode coverageCoverage.pyis required.To run a code coverage process:coveragerun--omit'*/.venv/*'-mpytesttest/&&coveragereport-mDevelopPlease install dependencies from files:requirements.txtrequirements-dev.txtrequirements-cicd.txtThen install thepre-commithook to forbidden pushing code if unit tests are not passing.IssuesFeel free tosubmit issuesand enhancement requests.ContributingPlease refer to project's style guidelines and guidelines for submitting patches and additions. In general, we follow the "fork-and-pull" Git workflow.Forkthe repo on GitHubClonethe project to your own machineCommitchanges to your own branchPushyour work back up to your forkSubmit aPull requestso that we can review your changesNOTE: Be sure to merge the latest from "upstream" before making a pull request!CreditsThank you very much to this used or integrated open source developments:ResourcesAmong others, to carry out this large and infinite project, we made use, among many others, of the following documentary resources.Thank you to their authors for sharing their knowledge with our team.HistoryPlease refer tothe changelog file.LicenseThe MIT LicenseCopyright (c) 2021Deepnox SAS, Paris, France.Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: loadgui
load-screenWanna create a loading screen ideal for your Python console project? You came to the right place.Use "pip install loadgui" to install library(Package published in PyPI as "loadgui 1.0.0")DocsFirst of all, to test if the library is working, run themain.py inside loadgui-master\loadguiIf nothing outputs/Outputs "OS compatible with library", you are good to go!Start the loading screenTo start loading:Import the library. Import loadgui.Prefixes for next step: D = delay, a = all, t = text, r = right, d = down, l = left, u = upCall load_screen(rD, dD, lD, uD, aD, t)OPTIONAL STEPS [For 1 second delay for each: load_screen(0, 0, 0, 0, 1, "TEXT")For 1 second delay added for each: load_screen(0, 1, 2, 3, 1, "TEXT")]No need to download any additional libraries
Package: loadinganim
loadinganimA simple terminal loading messagefrom loadinganim import LoadingAnim
import time

#Animation1
loader = LoadingAnim(message='Please Wait',animType=0)
loader.start()
time.sleep(5)
loader.stop()

#Animation2
loader = LoadingAnim(message='Please Wait',animType=1)
loader.start()
time.sleep(5)
loader.stop()Install:pip install loadinganimFor pip3:pip3 install loadinganim
Package: loadingbar
Python Loading BarPython module to display a nice loading bar in a terminal window.InstallGo to the module directory and run:$ pip install setup.pyOr:$ python3 setup.py installGetting StartedThere are 3 different loading bar:Standard loading barLoading bar with size loaded, speed and remaining timeLoading bar with infos above plus a custom message (usefull to display a verbose loading bar)Option 1Standard loading bar without any other infos.importloadingtotal_file_size=1000# Create a loading bar object with total_file_size in byteslb=loadingbar.LoadingBar(total_file_size)# For every piece of fileforchunkinfile:# Update the loading bar with the len of new datalg.update(len(chunk))# When finished, display a 100% loading barlg.done()Option 2Standard loading bar with infos such as size downloaded, speed, eta.importloadingtotal_file_size=1000lb=loadingbar.InfoLoadingBar(total_file_size)# Run as aboveOption 3This specialInternetLoadingBarsmooth the speed calculation by taking the overall average time rather than a instant speed.importloadingtotal_file_size=1000lb=loadingbar.InternetLoadingBar(total_file_size)# Run as aboveOption 4Loading bar that displays a message, like for example the filename that it is downloaded. Two options:loadingbar.MessageLoadingBarloadingbar.VerboseLoadingBarimportloadingtotal_file_size=1000lb=loadingbar.VerboseLoadingBar(total_file_size)# For every piece of fileforchunkinfile:# Update the loading bar with the len of new datalg.update(len(chunk),"Message to be displayed, such as filename, etc.")# When finished, display a 100% loading barlg.done()Option 5Add a percentage after the loading bar.loadingbar.PercentageLoadingBar(tot_size)loadingbar.PercentageInfoLoadingBar(tot_size)Option 6Add a percentage after the loading bar.loadingbar.PercentageBeforeLoadingBar(tot_size)loadingbar.PercentageBeforeLoadingBarAndInfo(tot_size)CustomizationIf a new and custom loading bar is needed, you can implement a new one by inheriting from the LoadingBar class or the abstract class ILoadingBar.
See loading > loading_bar.py for examples.LicenseMIT license.
Feel free to use, share, or improve it.
Package: loading-bars
loading-barsWelcome to loading-bars, a simple set of loading bars to make your life easy!InstallationTo install loading-bars simply use pip, no other modules requiredRequirements: Python 3.xpip install loading-barsUsageloading-bars currently contains 3 different loading bars:progress_bar(int)This function creates a progress bar with a desired size and percentageRequires the current percentage valuedinamic_bar()This function will make the first progress bar dinamic and very customizableDoesn't require any arguments to run the following example:loading_info()This function will show a information while loads by adding dotsDoesn't require any arguments to run [INFO] from following example:Thanks, I hope you find this useful!Found a error or want to contribute? Feel free to visit mygithub repository