Saravanan666/pypi-org huggingface dataset:
Package: outlier-utils
Utility library for detecting and removing outliers from normally distributed datasets using theSmirnov-Grubbstest.RequirementsPython(version 3.8 or later)SciPyNumPyOverviewBoth the two-sided and the one-sided version of the test are supported. The former allows extracting outliers from both ends of the dataset, whereas the latter only considers min/max outliers. When running a test, every outlier will be removed until none can be found in the dataset. The output of the test is flexible enough to match several use cases. By default, the outlier-free data will be returned, but the test can also return the outliers themselves or their indices in the original dataset.ExamplesTwo-sided Grubbs test with a Pandas series input>>> from outliers import smirnov_grubbs as grubbs
>>> import pandas as pd
>>> data = pd.Series([1, 8, 9, 10, 9])
>>> grubbs.test(data, alpha=0.05)
1     8
2     9
3    10
4     9
dtype: int64Two-sided Grubbs test with a NumPy array input>>> import numpy as np
>>> data = np.array([1, 8, 9, 10, 9])
>>> grubbs.test(data, alpha=0.05)
array([ 8,  9, 10,  9])One-sided (min) test returning outlier indices>>> grubbs.min_test_indices([8, 9, 10, 1, 9], alpha=0.05)
[3]One-sided (max) tests returning outliers>>> grubbs.max_test_outliers([8, 9, 10, 1, 9], alpha=0.05)
[]
>>> grubbs.max_test_outliers([8, 9, 10, 50, 9], alpha=0.05)
[50]LicenseThis software is licensed under the MIT License.
Package: outline
Django Outline==============[![Gitter](https://badges.gitter.im/Join Chat.svg)](https://gitter.im/powellc/outline?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)[![BuildStatus](https://travis-ci.org/powellc/outline.svg?branch=master)](https://travis-ci.org/powellc/outline)In the spirit of [playdoh](https://github.com/mozilla/playdoh), this projectaims to provide a base Django app full of best-practices and pre-installedapplications.It also includes a rudimentary makefile that helps get things started andalso plays nice with setuptools. That means you can actually use thestandard python setup method of installation, giving you a command linetool to run the server.All production settings should be handled via the environment, whichmeans you can leave the app installed in your python library and justuse the cli tool. More exmaples of this to follow.Start your engines, err projects!---------------------------------Your first order of business is to rename some things. Unless your projectis also called outline, you'll likely want to rename things. The easiest wayto get started is:make name="<myproject_name>" renameThat should do all the important replacements. The final step will be removingthe .git folder and initializing your own repository and lastly tweaking thesetup.py file, else you're likely to give me credit for your project and toprovide a pretty terribly confusing description to PyPI if your project everlands there.Easy bootstrapping!-------------------Powered by the ubiquitous Makefile ... this should be pretty easy:1. make install2. make run3. open your browser to: http://127.0.0.1:45000Libraries, libraries, libraries!-----------------------------Of course, we could provide a vagrant file and a provisoner and allthat jazz. But I'd rather provide a make file for installing everythinginto a venv and let you muck about with libraries. Those of you onLinux shouldn't have too much trouble installing the requisite developmentlibraries below. The names are for debian-based distros, but theyexist for all major distros.On Mac it may be a little tricker. Homebrew will get you quite far, butfirst you have to install the bloated XCode and the CLI tools.The libraries are:* libmemcached-dev* libfreetype6-dev* libjpeg-dev
Package: outline-api
Outline APIOutline API is a wrapper api written in python to access Outline VPN API services. Outline VPN APIs are used for Outline keys maintenance as well as for monitoring purposes. The package also provides wrappers to access Prometheus on the Outline VPN.Installuse pip to install the package:pip install outline-apiUsing packageimport the package and cerate a management object.fromoutline_apiimport(Manager,get_key_numbers,get_active_keys)apiurl="http://127.0.0.1/apikey"apicrt="apicert"manager=Manager(apiurl=apiurl,apicrt=apicrt)new_key=manager.new()ifnew_keyisnotNone:print(new_key)keys=get_key_numbers("127.0.0.1","999")print(keys)active_keys=get_active_keys("127.0.0.1","999")print(active_keys)CHANGELOG0.0.6 (2023-02-28)Add an optional label argument for new keys0.0.5 (2021-10-29)Add custom error exceptions0.0.4 (2021-10-27)Fix timeout values0.0.3 (2021-07-30)Fix return values in case of error0.0.1 (2020-08-01)First version
Package: outline-cli
outline-cliA command line tool that can help you manage your Outline VPN server more easily.
It support all the API inthis.And more:Create access key by email.Batch create access key by email list.and it will send VPN information to the user(s) by Gmail.How to use?pip install outline-cliPut your gmail and Outline VPN credential information to app.ini.ExampleRun outline cli with following command:outline-cli
Package: outline-router
IntroductionTODO: Give a short introduction of your project. Let this section explain the objectives or the motivation behind this project.Getting StartedTODO: Guide users through getting your code up and running on their own system. In this section you can talk about:Installation processSoftware dependenciesLatest releasesAPI referencesBuild and TestTODO: Describe and show how to build your code and run the tests.ContributeTODO: Explain how other users and developers can contribute to make your code better.If you want to learn more about creating good readme files then refer the followingguidelines. You can also seek inspiration from the below readme files:ASP.NET CoreVisual Studio CodeChakra Core
Package: outliner-tracer
OutlinerHave you ever got confused trying to undestand python complex object invoking sequence?! Now it is a solved problem.Outliner is a Python utility designed to simplify the process of tracing the calling flow of callable objects within a complex Python object. It aims to help developers understand the order in which callable objects are invoked within complex code structures, making it easier to navigate and comprehend such structures.Table of ContentsExampleInstallationUsageFeaturesContributingExampleWe have the given complex object:classtest:def__init__(self)->None:self.func1()deffunc1(self):self.func2()returndeffunc2(self):returndeftest2():a=test()returnWith the outliner you can visualize the invoking flow in order with the default tree display:outliner --file_path=path-to-module --object_name=testoutput:test2││──1.__init__││──2.func1││──3.func2Or get more detailed data about invoked objects (-d="detailed_data"):outliner --file_path=path-to-module --object_name=test -d="detailed_data"output:('test2',{'call':1,'return':1,'line':2})('__init__',{'call':1,'return':1,'line':1})('func1',{'call':1,'return':1,'line':2})('func2',{'call':1,'return':1,'line':1})FeaturesFunction Tracing: Trace function calls, returns, and line execution within a Python module.Data Collection: Collect detailed data on function executions and execution flow.Method Tree: Display a tree of functions used by the object for object behavior exploration.Easy Integration: Simple and straightforward integration into your Python projects.Customizable: Fine-tune tracing parameters to suit your debugging and explorationInstallationAs the library hasn't been released yet, to use it on your machine, you will need to do following steps:Use pip install:Make sure that path contains the setup.py filepip install -i https://test.pypi.org/simple/ outlinerUsageThe Outliner library can be used via the command-line interface (CLI) to trace Python code. Follow these steps to use it:Open your terminal.Run the following command to trace a Python object's execution:bashCopy codeoutliner --file_path=<path-to-object> --object_name=<object-name> --object_args=<arguments-passed-to-object>Command Line Options--file_path: Specifies the path to the Python module containing the object to be traced.--object_name: Specifies the name of the object to be traced.--object_args: Optionally, you can specify arguments to pass to the object.--display: Optionally, you can choose the output type(tree or detaield_data)ContributingContributions to the Outliner library are welcome. If you have ideas for improvements, find any issues, or want to contribute to its development, please open anissueor submit apull requeston GitHub.
Package: outline-sdk
Async Outline manager sdkThanks for the reverse engineering and docs project:https://github.com/jadolg/outline-vpn-apiAutor: @jadolgExample:fromoutline_sdkimportService# Setup the access with the API URL (Use the one provided to you after the server setup)service=Service(url="https://127.0.0.1:51083/xlUG4F5BBft4rSrIvDSWuw/",# <--- `/` is requiredcert_sha256="4EFF7BB90BCE5D4A172D338DC91B5B9975E197E39E3FA4FC42353763C4E58765")# Get all access URLs on the serverforkeyinawaitservice.get_keys():print(key)# Create a new keynew_key=awaitservice.create_key()# Rename itawaitservice.rename_key(new_key.id,"new_key")# Delete itawaitservice.delete_key(new_key.id)# Set a monthly data limit for a key (20MB)awaitservice.set_data_limit(new_key.id,1000*1000*20)# Remove the data limitawaitservice.delete_data_limit(new_key.id)
Package: outlinesmlx
outlinesmlxoutlinesmlxis a minimalistic library aimed at adapting the Outlines library for use with the MLX framework.To install, use:pip install outlinesmlx.Outlinesprovides methods to control the generation of language models to make their output more predictable. Combined withMLX, it enables guided generation with large language models while leveraging Apple Silicon hardware.Design PrinciplesWe designed it as an adapter that replaces the PyTorch parts of the original Outlines library with MLX compatible components. We will continue to update it actively as Outlines evolves over time.Versioningoutlinesmlx-xis the MLX adapter foroutlines-x. Versions can easily be checked with :piplist|grepoutlinesWhy Outlines MLX?We believe that guided generation is an important technology that will define the future of AI applications beyond chatbots. As Apple Silicon chips become increasingly powerful, we aim to extend guided-generation capabilities to a whole new family of devices. The originalOutlineslibrary relies on PyTorch, and adapting it to MLX requires changing many key components.Installationoutlinesmlxcan be installed directly from the PyPI repository:pipinstalloutlinesmlxSupported ModelsThe models are imported using the librarymlx-lm.This allows for seamless importation of quantized models. You can import any model from the HuggingFace hub using this library.Load Model with an MLX BackendRefer to the examples folder and the originalOutlineslibrary for more use cases.importoutlinesmlxasoutlinesmodel=outlines.models.mlx("mlx-community/Mistral-7B-Instruct-v0.1-4bit-mlx")prompt="""You are a sentiment-labelling assistant.Is the following review positive or negative?Review: This restaurant is just awesome!"""answer=outlines.generate.choice(model,["Positive","Negative"])(prompt)DisclaimerThis library is maintained on a monthly basis. Due to the rapid evolution of the MLX framework and the original Outlines library, it may not be up-to-date with their latest advancements.outlinesmlxis designed for experiments with guided generation on Apple Silicon. Please refer to the originalOutlineslibrary for an up-to-date implementation.outlinesmlxis only compatible with MLX models. If you wish to perform guided generation using transformers or other architectures, please use the originalOutlineslibrary.ContributionsWe welcome external contributions!CitationPlease do not forget to cite the original paper:@article{willard2023efficient,title={Efficient Guided Generation for LLMs},author={Willard, Brandon T and Louf, R{\'e}mi},journal={arXiv preprint arXiv:2307.09702},year={2023}}
Package: outline-vpn-api
outline-vpn-apiA Python API wrapper forOutline VPNHow to usefromoutline_vpn.outline_vpnimportOutlineVPN# Setup the access with the API URL (Use the one provided to you after the server setup)client=OutlineVPN(api_url="https://127.0.0.1:51083/xlUG4F5BBft4rSrIvDSWuw",cert_sha256="4EFF7BB90BCE5D4A172D338DC91B5B9975E197E39E3FA4FC42353763C4E58765")# Get all access URLs on the serverforkeyinclient.get_keys():print(key.access_url)# Create a new keynew_key=client.create_key()# Rename itclient.rename_key(new_key.key_id,"new_key")# Delete itclient.delete_key(new_key.key_id)# Set a monthly data limit for a key (20MB)client.add_data_limit(new_key.key_id,1000*1000*20)# Remove the data limitclient.delete_data_limit(new_key.key_id)API documentationhttps://redocly.github.io/redoc/?url=https://raw.githubusercontent.com/Jigsaw-Code/outline-server/master/src/shadowbox/server/api.yml
Package: outlook-calendar-sync
CLI interface to scrape outlook calendar events from the webapp and insert them to a google calendar account.Free software: BSD 2-Clause LicenseInstallationpip install outlook-calendar-syncYou can also install the in-development version with:pip install https://github.com/mr55p-dev/python-outlook-calendar-sync/archive/main.zipDocumentationhttps://python-outlook-calendar-sync.readthedocs.io/DevelopmentTo run all the tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxOn the roadmap is:[ ] Create some error handling for the outlook sign up process
- [ ] Exception on invalid username
- [ ] Exception on invalid password
- [ ] Exception on invalid auth code[ ] Handle the case where authenticator is not required (either auto detect or use flag)[ ] Switch from using css selectors to XPath[ ] Put dependencies in the setuptools scriptChangelog0.0.0 (2022-11-24)First release on PyPI.
Package: outlookcalendarsyncer
OutlookCalendarSyncerHow to setup dev environmentPrerequisitesFollowing software is required to run spark application:Python 3PoetryPyenvRun# Install required python version$pyenvinstall3.9.6# Binding required python version to this directory$pyenvlocal3.9.6# Install poetry$pip3installpoetry# Resolve dependencies$poetryinstall# Check - all tests should pass$poetryrunpytest# Sync configured$poetryrunpython-moutlookcalendarsyncerHow to build package$poetrybuildHow to test$poetryrunpytest
Package: outlook-event-slack-bot
Microsoft Outlook Event API Slack BotThe repository includes a Python-based Slack Bot for MS Outlook events.FunctionalityThe application allows accessing shared calendars of a user and reading the corresponding weekly events via Microsoft API calls. In the next step, it is possible to send this event in the form of a Slack message to a connected Slack channel.Installationpip install outlook-event-slack-botExample of useimportargparsefromoutlook_event_slack_notification_bot.modelimportSlackAPI,OutlookCalendarApifromoutlook_event_slack_notification_bot.slackimportSlackfromoutlook_event_slack_notification_bot.outlook_calendarimportOutlookCalendarif__name__=="__main__":parser=argparse.ArgumentParser(description="Script to extract a user's Outlook calendar events and ""forward them to a Slack channel.")parser.add_argument("-wh","--webhook",type=str,required=True,help="Get the Slack webhook")parser.add_argument("-t","--tenant",type=str,required=True,help="Get the Microsoft tenant")parser.add_argument("-ci","--client-id",type=str,required=True,help="Get the Microsoft OAuth Client ID")parser.add_argument("-cs","--client-secret",type=str,required=True,help="Get the Microsoft OAuth Client secret")parser.add_argument("-scu","--shared_calendar_user",type=str,required=True,help="Get the Outlook shared calendar user")parser.add_argument("-scn","--shared_calendar_name",type=str,required=True,help="Get the Outlook shared calendar name")parser.add_argument("-cn","--custom_notification",type=str,required=True,help="Should be custom notifications send to the corresponding users, ""defined Outlook calendar event body?")args=parser.parse_args()outlook_calendar_api:OutlookCalendarApi=OutlookCalendarApi(tenant=args.tenant,client_id=args.client_id,client_secret=args.client_secret)outlook_calendar:OutlookCalendar=OutlookCalendar(outlook_calendar_api)events:list=outlook_calendar.get_events(args.shared_calendar_name,args.shared_calendar_user)events_cw:list=outlook_calendar.get_weekly_events(events)Slack(SlackAPI(args.webhook),args.custom_notification).send_slack_message(events_cw)Optimization potential:Add Integration testsContributionIf you would like to contribute something, have an improvement request, or want to make a change inside the code, please open a pull request.SupportIf you need support, or you encounter a bug, please don't hesitate to open an issue.DonationsIf you would like to support my work, I ask you to take an unusual action inside the open source community. Donate the money to a non-profit organization like Doctors Without Borders or the Children's Cancer Aid. I will continue to build tools because I like it and it is my passion to develop and share applications.LicenseThis product is available under the Apache 2.0 license.
Package: outlookmail
Outlook MailMake automatic many email related tasks in OutlookFree software: MIT licenseDocumentation:https://outlookmail.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.0.1 (2021-09-04)First release on PyPI.
Package: outlook-msg
outlook_msgoutlook_msgis a Python library byHamilton Groupto process the .msg files that
Users can export from Outlook. It is very common for users in organizations that use Outlook to archive data in this
format. For example, at Hamilton we see these files store in relation to deals we write. If we want to do automatic
processing in a way that feels most natural to end users we need to extract data from these files.This library is built on top of the excellentcompoundfileslibrary, without
which none of this would be possible.Getting StartedInstall using pip:pip install outlook_msgUsageTo open an email:fromoutlook_msgimportMessagewithopen('file.msg')asmsg_file:msg=Message(msg_file)# Contents are the plaintext body of the emailcontents=msg.body# Attachments can be read and saved like sofirst_attachment=msg.attachments[0]withfirst_attachment.open()asattachment_fp,open(first_attachment.filename,'wb')asoutput_fp:output_fp.write(attachment_fp.read())Running the testsWe usepytestto run our tests but you are best to use tox so you can test on all
supported Python versions and will ensure a clean environment.
Package: outlooktools
OutlookToolsTable of ContentsInstallationLicenseInstallationpip install outlooktoolsLicenseoutlooktoolsis distributed under the terms of theMITlicense.OutlookToolsWindows CLI tool to automate some Outlook activities.Works via MAPI interface to the user's Outlook session.Only works on Windows systemsCurrent functions:List mailboxesList foldersSave all attachments found in a given folder to a given locationSend a plain text email (as the current user) with an attachment as desired.When installed should put a "OutlookTools.exe" on your path so can run from the command lineThe MAPI interface can do A LOT.  Basically anything you can do with VBA as describedhere:Have fun extending
Package: outlyer-plugin
Outlyer Pluginapi for definining native Outlyer PluginsclassPlugin:"""The Plugin API.Users must derive from this class when implementing a custom Plugin"""defcollect(self)->Status:"""Perform collections operations for the provided Target"""defgauge(self,name:str,labels:Optional[dict])->Gauge:"""Get a Gauge instance for the specified Name/Labels"""defcounter(self,name:str,labels:Optional[dict])->Counter:"""Get a Counter instance for the specified Name/Labels"""defget(self,key:str,default:any)->any:"""Get a Target config property"""Usagefromoutlyer_pluginimportPlugin,StatusclassMyPlugin(Plugin):defcollect(self):self.gauge(f'sys.cpu.user.pct').set(55)returnStatus.OKif__name__=='__main__':# To run the collectionsys.exit(MyPlugin().run())
Package: ou-tm351-jl-extensions
ou-tm351-jl-extensionsInstall from pypi asou-tm351-jl-extensionsJupyterLab 3: v0.1.2JupyterLab 4: v 0.2.0Recommended JupyterLab extensions for use in the OU TM351 module.This package will install several JupyterLab extensions that brand and extend a JupyterLab environment to support its use as a teaching and learning environment.Extensions installed:jupyterlab = "^4.0.1"
jupyterlab-ou-brand-extension = "^0.2.0"
jupyterlab-cell-status-extension = "^0.1.3"
jupyterlab-myst = "^1.1.3"
jupyterlab-empinken-extension = "^0.4.0"
jupyterlab-geojson = "^3.3.1"
jupyterlab-skip-traceback = "^5.0.0"
jupyterlab-git = "^0.41.0"
jupytext = "^1.14.5"
jupyter-archive = "^3.3.4"
jupyterlab-spellchecker = "^0.8.3"
jupyterlab-language-pack-fr-fr = "^3.6.post1"
jupyterlab-language-pack-zh-cn = "^3.6.post1"
jupyter-resource-usage = "^0.7.2"
stickyland = "^0.2.1"
#jupyterlab-tour = "^3.1.4"
jupyter-compare-view = "^0.2.4"
jupyterlab-filesystem-access = "^0.5.3"Check the installation by running:importou_tm351_jl_extensionsasouou.check_install()MaintenanceUpdate packages inpyproject.tomlby running:poetry updateFormal tests for use in CI will be added soon.
Package: out-of-core-fft
# out_of_core_fft <a href=”https://travis-ci.org/moble/out_of_core_fft”><img align=”right” hspace=”3” alt=”Status of automatic build and test suite” src=”https://travis-ci.org/moble/out_of_core_fft.svg?branch=master”></a> <a href=”https://github.com/moble/out_of_core_fft/blob/master/LICENSE”><img align=”right” hspace=”3” alt=”Code distributed under the open-source MIT license” src=”http://moble.github.io/spherical_functions/images/MITLicenseBadge.svg”></a>Fourier transforms are highly nonlocal, which can cause problems when dealing with very large data sets.  In particular,
standard algorithms cannot work with data sets too large to fit into memory.  On the other hand, the classic
Cooley-Tukey FFT algorithm shows that discrete Fourier transforms can be split up into smaller sub-problems.  This
module provides functions for FFTs that can work with the data directly on disk, extracting small subsets that fit into
memory, working on each individually, and then combining back onto disk to get the final result.  This implementation is
based on the algorithm presented by Thomas H. Cormen in “Algorithms for parallel processing” (1999).  A nontrivial
part of the implementation involves transposing the data on disk, for which I created a relatively simple, but fairly
fast, function included here simply astranspose.## UsageThese functions assume that the data to be manipulated are stored inHDF5files.  The FFT and inverse FFT are called
with something like`python import out_of_core_fftout_of_core_fft.fft('input.h5','x', 'output.h5', 'X')out_of_core_fft.ifft('input2.h5','X', 'output2.h5', 'x') `Here,xandXare names for the datasets within theHDF5files.  Note that nothing is returned, because the result
is stored on disk, as requested.See the docstrings for more details.## AcknowledgmentsThe work of creating this code was supported in part by the Sherman Fairchild
Foundation and by NSF Grants No. PHY-1306125 and AST-1333129.