Saravanan666/pypi-org huggingface dataset:
Package: openlicense
Python Project TemplateA low dependency and really simple to start project template for Python Projects.See alsoFlask-Project-Templatefor a full feature Flask project including database, API, admin interface, etc.FastAPI-Project-TemplateThe base to start an openapi project featuring: SQLModel, Typer, FastAPI, JWT Token Auth, Interactive Shell, Management Commands.HOW TO USE THIS TEMPLATEDO NOT FORKthis is meant to be used fromUse this templatefeature.Click onUse this templateGive a name to your project(e.g.my_awesome_projectrecommendation is to use all lowercase and underscores separation for repo names.)Wait until the first run of CI finishes(Github Actions will process the template and commit to your new repo)If you wantcodecovReports and Automatic Release toPyPIOn the new repositorysettings->secretsadd yourPYPI_API_TOKENandCODECOV_TOKEN(get the tokens on respective websites)Read the fileCONTRIBUTING.mdThen clone your new project and happy coding!NOTE:WAITuntil first CI run on github actions before cloning your new project.What is included on this template?🖼️ Templates for starting multiple application types:Basic low dependencyPython program (default)use this templateFlaskwith database, admin interface, restapi and authenticationuse this template.or Runmake initafter cloning to generate a new project based on a template.📦 A basicsetup.pyfile to provide installation, packaging and distribution for your project.Template uses setuptools because it's the de-facto standard for Python packages, you can runmake switch-to-poetrylater if you want.🤖 AMakefilewith the most useful commands to install, test, lint, format and release your project.📃 Documentation structure usingmkdocs💬 Auto generation of change log usinggitchangelogto keep a HISTORY.md file automatically based on your commit history on every release.🐋 A simpleContainerfileto build a container image for your project.Containerfileis a more open standard for building container images than Dockerfile, you can use buildah or docker with this file.🧪 Testing structure usingpytest✅ Code linting usingflake8📊 Code coverage reports usingcodecov🛳️ Automatic release toPyPIusingtwineand github actions.🎯 Entry points to execute your program usingpython -m <openlicense>or$ openlicensewith basic CLI argument parsing.🔄 Continuous integration usingGithub Actionswith jobs to lint, test and release your project on Linux, Mac and Windows environments.Curious about architectural decisions on this template? readABOUT_THIS_TEMPLATE.mdIf you want to contribute to this template please open anissueor fork and send a PULL REQUEST.❤️ Sponsor this projectopenlicenseAwesome openlicense created by torrentsaiInstall it from PyPIpipinstallopenlicenseUsagefromopenlicenseimportBaseClassfromopenlicenseimportbase_functionBaseClass().base_method()base_function()$python-mopenlicense#or$openlicenseDevelopmentRead theCONTRIBUTING.mdfile.
Package: openlineage-dbt
OpenLineage dbt integrationWrapper script for automatic metadata collection from dbtFeaturesMetadataModel run lifecycleModel inputs / outputsRequirementsPython >= 3.8dbt >= 0.20Right now,openlineage-dbtonly supportsbigquery,snowflake,sparkandredshiftdbt adapters.Installation$pip3installopenlineage-dbtTo install from source, run:$pipinstall.ConfigurationHTTPBackend Environment Variablesopenlineage-dbtuses the OpenLineage client to push data to the OpenLineage backend.The OpenLineage client depends on environment variables:OPENLINEAGE_URL- point to service which will consume OpenLineage eventsOPENLINEAGE_API_KEY- set if consumer of OpenLineage events requiresBearerauthentication keyOPENLINEAGE_NAMESPACE- set if you are using something other than thedefaultnamespace for job namespace.LoggingIn addition to conventional logging approaches, the OpenLineage dbt wrapper script provides an alternative way of configuring its logging behavior. By setting theOPENLINEAGE_DBT_LOGGINGenvironment variable, you can establish the logging level for theopenlineage.dbtand its child modules.You can also set log level ofdbtolwhich is deprecated.UsageTo begin collecting dbt metadata with OpenLineage, replacedbt runwithdbt-ol run.Additional table and column level metadata will be available ifcatalog.json, a result of runningdbt docs generate, will be found in the target directory.If you need to send events without running the job you can use the commanddbt-ol send-events, it will send the metadata of your last run without running the job.SPDX-License-Identifier: Apache-2.0Copyright 2018-2023 contributors to the OpenLineage project
Package: openllm-client
👾 OpenLLM ClientOpenLLM Client: Interacting with OpenLLM HTTP/gRPC server, or any BentoML server.📖 IntroductionWith OpenLLM, you can run inference with any open-source large-language models,
deploy to the cloud or on-premises, and build powerful AI apps, and more.To learn more about OpenLLM, please visitOpenLLM's README.mdThis package holds the underlying client implementation for OpenLLM. If you are
coming from OpenLLM, the client can be accessed viaopenllm.client.It provides somewhat of a "similar" APIs tobentoml.Client(viaopenllm_client.min) for interacting with OpenLLM server. This can also be extended to use with general
BentoML server as well.[!NOTE]
The component of interop with generic BentoML server will be considered asEXPERIMENTALand
will be refactored to new client implementation soon!
If you are just using this package for interacting with OpenLLM server, The API should be the same asopenllm.clientnamespace.importopenllmclient=openllm.client.HTTPClient()client.query('Explain to me the difference between "further" and "farther"')📔 CitationIf you use OpenLLM in your research, we provide acitationto use:@software{Pham_OpenLLM_Operating_LLMs_2023,author={Pham, Aaron and Yang, Chaoyu and Sheng, Sean and  Zhao, Shenyang and Lee, Sauyon and Jiang, Bo and Dong, Fog and Guan, Xipeng and Ming, Frost},license={Apache-2.0},month=jun,title={{OpenLLM: Operating LLMs in production}},url={https://github.com/bentoml/OpenLLM},year={2023}}Click me for full changelog
Package: openllm-core
🦑 OpenLLM CoreOpenLLM Core: Core components for OpenLLM.📖 IntroductionWith OpenLLM, you can run inference with any open-source large-language models,
deploy to the cloud or on-premises, and build powerful AI apps, and more.To learn more about OpenLLM, please visitOpenLLM's README.mdThis package holds the core components of OpenLLM, and considered as internal.Components includes:Configuration generation.Utilities for interacting with OpenLLM server.Schema and generation utilities for OpenLLM server.📔 CitationIf you use OpenLLM in your research, we provide acitationto use:@software{Pham_OpenLLM_Operating_LLMs_2023,author={Pham, Aaron and Yang, Chaoyu and Sheng, Sean and  Zhao, Shenyang and Lee, Sauyon and Jiang, Bo and Dong, Fog and Guan, Xipeng and Ming, Frost},license={Apache-2.0},month=jun,title={{OpenLLM: Operating LLMs in production}},url={https://github.com/bentoml/OpenLLM},year={2023}}Click me for full changelog
Package: openllmtelemetry
llm-traceguardllm-traceguardis an open-source Python library that provides Open Telemetry integration with Large Language Models (LLMs). It is designed to facilitate tracing and safeguarding applications that leverage LLMs, ensuring better monitoring and reliability.FeaturesEasy integration with Open Telemetry for LLM applications.Real-time tracing and monitoring of LLM-based systems.Enhanced safeguards and insights for your LLM applications.InstallationTo installllm-traceguard, simply use pip:pipinstallllm-traceguardUsage 🚀Here's a basic example of how to usellm-traceguardin your project:importllm_traceguardllm_traceguard.instrument()Requirements 📋Python 3.8 or higheropentelemetry-apiopentelemetry-sdkContributing 👐Contributions are welcome! For major changes, please open an issue first to discuss what you would like to change. Please make sure to update tests as appropriate.License 📄llm-traceguardis licensed under the Apache-2.0 License. SeeLICENSEfor more details.Contact 📧For support or any questions, feel free to contact us atsupport@whylabs.ai.
Package: openllmtrace
llm-traceguardllm-traceguardis an open-source Python library that provides Open Telemetry integration with Large Language Models (LLMs). It is designed to facilitate tracing and safeguarding applications that leverage LLMs, ensuring better monitoring and reliability.FeaturesEasy integration with Open Telemetry for LLM applications.Real-time tracing and monitoring of LLM-based systems.Enhanced safeguards and insights for your LLM applications.InstallationTo installllm-traceguard, simply use pip:pipinstallllm-traceguardUsage 🚀Here's a basic example of how to usellm-traceguardin your project:importllm_traceguardllm_traceguard.instrument()Requirements 📋Python 3.8 or higheropentelemetry-apiopentelemetry-sdkContributing 👐Contributions are welcome! For major changes, please open an issue first to discuss what you would like to change. Please make sure to update tests as appropriate.License 📄llm-traceguardis licensed under the Apache-2.0 License. SeeLICENSEfor more details.Contact 📧For support or any questions, feel free to contact us atsupport@whylabs.ai.
Package: openlmi-scripts
openlmi-scripts===============Client-side python libraries and *LMI Meta-command* for systemmanagement through OpenLMI providers.It serves as a base for small python eggs targeted on one or moreOpenLMI providers. We call these eggs scripts. They are installedseparately although they can depend on each other.They contain python library itself as well as command line interface.This interface is registered with *LMI Meta-command* which is a part ofOpenLMI Tools. *LMI Meta-command* loads it and offers to interface withbroker through command line.For more information please refer to online documentation on`pythonhosted <http://pythonhosted.org/openlmi-tools/index.html>`__.Take a look at `scripts upstreamrepository <https://github.com/openlmi/openlmi-scripts>`__ forinspiration on how to write your own scripts.Deprecation warning~~~~~~~~~~~~~~~~~~~``openlmi-scripts`` is deprecated egg. It contains just *LMIMeta-command* which has been moved to ``openlmi-tools`` (version``0.9.1``). Newer scripts (``openlmi-scripts-*``) now depend just on``openlmi-tools``. Use this package only with older *tools*.Dependencies------------Code base is written for ``python 2.7``. There are following pythondependencies:-  openlmi-tools >= 0.9 and < 0.9.1(`PyPI <https://pypi.python.org/pypi/openlmi-tools>`__)-  python-docopt-  pandocInstallation------------Use standard ``setuptools`` script for installation:::$ cd openlmi-scripts/commands/$CMD$ make setup$ python setup.py install --userThis installs particular client library and command line interface for*LMI Meta-command*.Script eggs are also available on *PyPI*, install them with:::$ # add any provider you want to interact with$ pip install --user openlmi-scripts-service openlmi-scripts-softwareCheck out`this <https://pypi.python.org/pypi?%3Aaction=search&term=openlmi-scripts&submit=search>`__site listing all available script eggs.--------------
Package: openlmi-tools
OpenLMI=======The OpenLMI project provides a common infrastructure for the managementof Linux systems. Capabilities include configuration, management andmonitoring of hardware, operating systems, and system services. OpenLMIincludes a set of services that can be accessed both locally andremotely, multiple language bindings, standard APIs, and standardscripting interfaces.OpenLMI-tools=============OpenLMI-tools currently contains *LMIShell*, a (non)interactive commandinterpreter for CIM objects access and *LMI metacommand*, which servesas a command line interface to OpenLMI Providers, which utilizes*LMIShell*.Dependencies------------OpenLMI tools require-  python2.7-  python-setuptools-  lmiwbem-  python-docoptUploading to PyPI~~~~~~~~~~~~~~~~~Since *PyPI* expects README file to be in a *reStructuredText* markuplanguage and the one present is written in *markdown*, it needs to beconverted to it. So please make sure you have ``pandoc`` installedbefore running:::$ python setup.py sdist uploadInstallation------------Use standard ``setuptools`` script for installation:::$ cd cli$ make # generate setup.py$ python setup.py install --root=/path/to/install/directoryIf you have limited access to system path, you may wish to install touser directory instead:::$ python setup.py install --userThis installs just the *LMIShell*, *LMI metacommand* and client-sidelibraries. To install *LMI commands*, please refer to`git <https://github.com/openlmi/openlmi-scripts>`__.Example usage-------------See ``man/lmishell.1`` manual page or ``man/lmi.1``Or visit our documentation on`pythonhosted <http://pythonhosted.org/openlmi-tools/index.html>`__.--------------
Package: openload-dl
openload_dlA python library and CLI tool which makes easy to download files from openload.coInstallationDescriptionInstallationUbuntu or Debian:sudo apt install python3-pip
pip3 install openload_dlWindows:InstallPython(don't forget to check the "ADD TO PATH" option).
Then open the command prompt and type:pip3 install openload_dlOn both Ubuntu and Windows:Download the latest version ofgeckodriver( for Firefox ) orchromedriver( for Chrome ), extract it and add the executable to PATH or put it in the same directory of the script.[In order for this script to work you need to haveFirefoxorChromeinstalled on your system.]DescriptionUsage: openload-dl [OPTIONS] [URLS]...

Options:
  --get-download-url              Extract only file's download url
  --preferred-browser [firefox|chrome]
                                  Select the browser to use  [default:
                                  firefox]
  --no-headless                   Show the browser
  --chunk-size INTEGER            Set the downloader chunk size in bytes
                                  [default: 1000000]
  -q, --quiet                     Don't print download progress information
  --help                          Show this message and exit.
Package: openlobby-app
# Open Lobby AppWeb based application for Open Lobby - register of lobby meetings.This application comunicates with Open Lobby Server over
[GraphQL API](http://graphql.org). The server is available in repository
[openlobby/openlobby-server](https://github.com/openlobby/openlobby-server).## ConfigurationConfiguration is done by environment variables:DEBUG- Set to any value to turn on debug mode. Don’t use in production!SECRET_KEY- long random secret string (required if not in debug mode)OPENLOBBY_SERVER_DSN- Open Lobby Server DSN (default:http://localhost:8010)APP_URL- URL where you run application (default:http://localhost:8020)## DockerDocker image is at Docker Hub
[openlobby/openlobby-app](https://hub.docker.com/r/openlobby/openlobby-app/).
It exposes web application on port 8020. You should provide it environment
variables for configuration (at leastSECRET_KEY).## DemoDemo of Open Lobby with instructions is in repository
[openlobby/demo](https://github.com/openlobby/demo).## Local run and developmentYou need to have Python 3 installed. Clone this repository and run:make init-env- prepares Python virtualenv in dir.envsource .env/bin/activate- activates virtualenvmake install- installs requirements and application in development modemake run- runs development server on port8020Now you can use web interface athttp://localhost:8020Next time you can just do steps 2 and 4.Application development server assumes that you have
[openlobby/openlobby-server](https://github.com/openlobby/openlobby-server).
running onhttp://localhost:8010. You can override this address in environment
variableOPENLOBBY_SERVER_DSN. E.g.OPENLOBBY_SERVER_DSN=http://my-server:8010 make run### TestingRun:pytest
Package: openloss
OPENLOSS: Open-set Learning Cost FunctionsThis project encompasses a list of three cost functions recently designed for open-set learning and classification, available through theOpenloss Package[PyPi link] so that it can be easily installed in your environment:openloss.EntropicOpenSetLoss(num_classes, reduction='mean', weight=None)[1,3]openloss.MaximalEntropyLoss(num_classes, margin=0.5, reduction='mean', weight=None)[1,2]openloss.ObjectoSphereLoss(min_magnitude=10.0, reduction='mean')[1,3]Our most recent contribution, the Maximal Entropy Loss (MEL), increases the entropy for negative samples and attaches a penalty to known target classes in pursuance of gallery specialization.
MEL was initially designed to address open-set face recognition applications; however, it can also be employed in any classification task.The proposed functions' API models the conventional cost functions available under the PyTorch framework so that it can be invoked according to the code block below:importopenlossimporttorch# Generate 10 positive classes and one negative classnum_classes,num_samples=11,100values=torch.randn(num_samples,num_classes,requires_grad=True)labels=torch.randint(num_classes,(num_samples,),dtype=torch.int64)-1# Feed criterion with both values and labels and compute losscriterion=openloss.MaximalEntropyLoss(num_classes=num_classes,margin=0.5)loss_score=criterion(values,labels)loss_score.backward()There is anotebook tutorialimplemented with thePyTorchframework as well as theBOB.measurelibrary demonstrating how to use MEL in open-set applications.
The tutorial relies on E-MNIST and K-MNIST datasets in which letters make up the gallery and probe sets, numbers constitute the negative training set whereas Korean digits compose the set of unknown probe samples.
If you have further questions about the proposed approach, you can reach the corresponding author though the contact form available atwww.vareto.com.br.If you make use of the aforementioned cost functions, please cite all or one of the following works:@article{vareto2024open,title={Open-set face recognition with maximal entropy and Objectosphere loss},author={Vareto, Rafael Henrique and Linghu, Yu and Boult, Terrance Edward and Schwartz, William Robson and G{"u}nther, Manuel},journal={Image and Vision Computing},volume={141},pages={104862},year={2024},publisher={Elsevier}}@inproceedings{vareto2023open,title={Open-set Face Recognition with Neural Ensemble, Maximal Entropy Loss and Feature Augmentation},author={Vareto, Rafael Henrique and G{"u}nther, Manuel and Schwartz, William Robson},booktitle={2023 36th SIBGRAPI Conference on Graphics, Patterns and Images (SIBGRAPI)},pages={55--60},year={2023},organization={IEEE}}@inproceedings{gunther2020watchlist, title={Watchlist adaptation: protecting the innocent},author={G{"u}nther, Manuel and Dhamija, Akshay Raj and Boult, Terrance E},
booktitle={2020 International Conference of the Biometrics Special Interest Group (BIOSIG)},pages={1--7},year={2020},organization={IEEE}}
Package: openlp3
OpenLP Python SDKOpen Loyality Points (OpenLP) is an opensource Loyality Point platform build top on public blockchain.Auther: Midhun ChandrasekharDate: Sep 04, 2022Place: Kerala, InBuildTechnologiesDocumentation*OpenLP Version 0.1.0 DocStatusInstallationpip install web3pip install openlp3UsageDeploy smart contract fromhttps://github.com/Midhun-Chandrasekhar/OpenLPon EVMcompatible blockchain (etherium).Importfrom openlp import OpenLPInitializingolp = OpenLP3("network_address", "contract_address", "contract_owner_private_key", "contract_abi")Contract Informationolp.contract_info()Issue loyality point to walletolp.issue_points("wallet_address", 1000)Burn loyality point to walletolp.burn_points("wallet_address", 100)Get Loyality balanceolp.user_points("wallet_address")LicenseContributing
Package: openlr
OpenLR PythonZero dependency Python implementation forOpenLR™XML and binary physical formats according tothe White Paperandthe reference implementation.InstallationYou need a Python version >= 2.7.pip install openlr
python -m openlr CwGkNSK5WhtzAv9+/5kbAw==LicenseReleased underthe Apache License 2.0.
Copyright (c) 2016-2020 TomTom NV.
Package: openlr-dereferencer
openlr-dereferencerThis is a Python package for decoding OpenLR™ location references on target maps.It implementsChapter H – Decoderin the OpenLR whitepaper, except "Step 1 – decode physical data".Its purpose is to give insights into the map-matching process.DependenciesPython ≥ 3.6geographiclib (PyPi package)shapely (PyPi package)openlr(PyPi package; implements the decoder's step 1 from the whitepaper)For unittests: SpatiaLiteStateDecoding line locationsDecoding 'point along line' locationsDecoding 'POI with access point' locationsStructureThis package is divided into the following submodules:mapsContains an abstract map class, which you may want to implement for your target map.maps.wgs84provides methods for reckoning with WGS84 coordinates.example_sqlite_mapImplements the abstract map class for the example map format used in the unittests and examplesdecodingThe actual logic for matching references onto a map.This includes finding candidate lines and scoring them, and assembling a dereferenced location.observerContains the observer class, allowing you to hook onto certain events in the decoding process.InstallationThis project is available on PyPi:pip3installopenlr-dereferencerUsageThedecode(reference, mapreader)function will take a location reference and return map objects.Usage ExampleFirst, implement theMapReaderclass for your map.  Theexample_sqlite_mapmodule is an implementation you may look at.Second, construct a location reference. For instance, parse an OpenLR line location string:fromopenlrimportbinary_decodereference=binary_decode("CwmG8yVjzCq0Dfzr/gErRRs=")Third, decode the reference on an instance of your map reader class:fromopenlr_dereferencerimportdecodereal_location=decode(reference,mapreader)real_location.lines# <- A list of map objectsConfigurationThedecodefunction takes in an optionalConfigobject containing decoding settings.
With it, you may specify the decoder's behaviour:fromopenlr_dereferencerimportdecode,Configmy_config=Config(geo_weight=0.66,frc_height=0.17,fow_height=0.17,bear_weight=0.0)decode(reference,mapreader,config=my_config)Loggingopenlr-dereferencerlogs all mapmatching decisions using the standard libraryloggingmodule.Use it to turn on debugging:importlogginglogging.basicConfig(level=logging.DEBUG)ObservingVia implementing theObserverinterface, you can hook onto certain events happening while decoding, and inspect the situation:fromopenlr_dereferencerimportDecoderObserver,SimpleObserver# Look at SimpleObserver for an example implementationmy_observer=SimpleObserver()decode(reference,mapreader,observer=my_observer)Development environmentFirstly create a Python virtual environment for the project.python3-mvenv.venvActivate the virtual environment.source.venv/bin/activateInstall the dependency packages into the virtual environment.pipinstallopenlrgeographiclibshapelyYou may need to install the spatialite module for sqlite if this is not already present.sudoaptinstalllibsqlite3-mod-spatialiteTo run the decoding tests.python3-munittestMore DocumentationYou are welcomed to read the generated API documentation athttps://openlr-dereferencer-python.readthedocs.io.