Saravanan666/pypi-org huggingface dataset:
Package: outcome-eventkit
eventkit-pyA toolkit for emitting and handling events, following the CloudEvent spec.Installationpoetryaddoutcome-eventkitUsageIt's a good idea to be familiar with theCloudEvent v1.0 specbefore using this library.The library implements the following (but is extensible):The Core Event objectA JSON formatterThe HTTP Protocol Bindings (Structured and Binary)Event Examplefromoutcome.eventkitimportCloudEvent,CloudEventDatafromoutcome.eventkit.formats.jsonimportJSONCloudEventFormatfromoutcome.eventkit.protocol_bindings.httpimportStructuredHTTPBinding,BinaryHTTPBindingimportrequests# Create a payload, specifying how it will be encodeddata=CloudEventData(data_content_type='application/json',data={'hello':'world'})# Create an eventevent=CloudEvent(type='co.outcome.events.sample',source='example',data=data)# Create a JSON representation of the eventserialised_event=JSONCloudEventFormat.encode(event)# Or...# Create a HTTP message with the eventhttp_message=BinaryHTTPBinding.to_http(event)# Or...# Create a structured HTTP message with the event and a JSON formatterhttp_message=StructuredHTTPBinding.to_http(event,JSONCloudEventFormat)# Post the event somewhere...requests.post('http://example.org',headers=http_message.headers,data=http_message.body)Dispatch Examplefromoutcome.eventkitimportdispatch,CloudEvent# You can register event handlers that will be called# when a corresponding event is dispatched# Explicitlydefmy_event_handler(event:CloudEvent)->None:...# Register a handler for an event typedispatch.register_handler('co.outcome.event',my_event_handler)# Or via a decorator@dispatch.handles_events('co.outcome.event','co.outcome.other-event')defmy_other_handler(event:CloudEvent)->None:...# Then notify all registered handlers of an eventev=CloudEvent(type='co.outcome.event',source='example')dispatch.dispatch(ev)By default, all handlers are stored in a single registry, but you can provide your own registry to theregister_handler/handles_events/dispatchmethods with theregistrykeyword argument.fromoutcome.eventkitimportdispatchfromcollectionsimportdefaultdictmy_registry:dispatch.CloudEventHandlerRegistry=defaultdict(list)@dispatch.handles_events('co.outcome.event',registry=my_registry)defmy_handler(event:CloudEvent)->None:...ev=CloudEvent(type='co.outcome.event',source='example')dispatch.dispatch(ev,registry=my_registry)DevelopmentRemember to run./pre-commit.shwhen you clone the repository.
Package: outcome-logkit
logkit-pyLogging helpers.Installationpoetryaddoutcome-logkitUsagelogkitis a wrapper aroundstructlogthat configures it with the following:Sets log level based onAPP_ENVenvironment variableAutomatically outputs Stackdriver-compliant JSON to stdout when running in a GCP environment (AppEngine, CloudRun, GKE, etc.)Intercepts all messages sent to the standard library loggers and processes them transparentlyConfigures structlog to provide async-safe context valuesInitializationlogkitneeds to be initialized before being used. This initialization configuresstructlogand sets up the intercept for the standard logging library.NoteIt's important to do this as early as possible in the program to ensure that no other imports start logging messages before the intercept has been configured. You can use# isort:skipto ensureisortdoesn't reorder the import.# Important that this happens before any other importsfromoutcome.logkitimportinit_logging# isort:skipinit_logging()# isort:skipLog LevelYou can provide alevelparameter toinit_loggingto define the default log-level. You can use the built-in log levels from theloggingmodule (e.g.logging.INFO). If you don't provide a level, it will automatically be set based on theenv.is_prod()method from theoutcome-utilspackage.importlogginginit_logging(level=logging.INFO)Custom ProcessorsYou can provide an array of your ownstructlog processorstoinit_logging. They will be merged into the processors provided bylogkit.init_logging(processors=[my_custom_processor])LoggingTo log withlogkit, you can either use the standard library logging, or use the structlog interface. Both can be used to pass structured data to the log entries. Using the structlog interface ismarginallyfaster, since all the messages sent to the standard logging library are sent to structlog anyway.importloggingfromoutcome.logkitimportget_logger# Using the standard librarylogger=logging.getLogger(__name__)logger.info('my_message',user_id='1')# Using the structlog interfacestructured_logger=get_logger(__name__)structured_logger.info('my_message',user_id='1')Async-safe context varsYou can set "global" variables that are async safe usingoutcome.logkit.context.importloggingfromoutcome.logkitimportget_logger,contextcontext.add(user_id='1')structured_logger=get_logger(__name__)structured_logger.info('my_message')# user_id=1 will be added to this log eventcontext.remove('user_id')TestingIf you want to capture logs during your tests, you can useconfigure_structlogandlog_outputfixtures.@pytest.mark.usefixtures('configure_structlog')deftest_log_output(log_ouput):assertlog_output.entries==[]# do somethingassertlog_output.entries==[...]You can also define the capturedlog levelor addcustom processorsthanks to these handy fixtures:@pytest.fixturedeflog_level():returnlogging.DEBUG@pytest.fixturedeflog_processors(log_output):my_custom_processor=fooreturn[my_custom_processor,log_output]@pytest.mark.usefixtures('configure_structlog')deftest_log_output(log_ouput):assertlog_output.entries==[]# do somethingassertlog_output.entries==[...]DevelopmentRemember to run./bootstrap.shwhen you clone the repository.
Package: outcome-pypicloud-storage-gcs
pypicloud-storage-gcs-pyA fork-safe verion of the GCS Storage backend.The GCS library usesrequeststo handle HTTP/S calls, but the SSL-state management insiderequestsdoesn't handle os.fork calls very well. By default, the pypicloud GCS storage adapter creates the client before forking, so the same GCS client gets used across multiple processes which leads to issues.This replacement defers the creation of the GCS client until the process has been forked.UsageInstallationpoetryaddoutcome-pypicloud-storage-gcsConfigurationTo use the storage backend, configure it in theserver.ini. The settings/options for the adapter are identical to those for the original adapter.# Set up GCS storagepypi.storage=outcome.pypicloud_storage_gcs.ThreadsafeGoogleCloudStoragestorage.bucket=my-bucketDevelopmentRemember to run./pre-commit.shwhen you clone the repository.
Package: outcome-read-toml
read-toml-pyA small utility to read keys from TOML files.UsageInstallationpoetryaddoutcome-read-tomlUsageThe utility reads the value specified by the key from the provided TOML file, and prints it to stdout.The path parameter should be a '.' separated sequences of keys that correspond to a path in the TOML structure.Example TOML file:title="My TOML file"[info]version="1.0.1"[tools.poetry]version="1.1.2"files=['a.py','b.py']Read standard keys:read-toml--pathmy_file.toml--keytitle# "My TOML file"read-toml--pathmy_file.toml--keyinfo.version# "1.0.1"Read arrays:read-toml--pathmy_file.toml--keytools.poetry.files# "a.py b.py"read-toml--pathmy_file.toml[0]--keytools.poetry.files# "a.py"You can't read non-leaf keys:read_toml.py--pathmy_file.toml--keytools# KeyErrorYou can check if a key exists:read-toml--pathmy_file.toml--keytitle--check-only# 1read-toml--pathmy_file.toml--keyunknown_key--check-only# 0DevelopmentRemember to run./pre-commit.shwhen you clone the repository.
Package: outcome-utils
utils-pyA set of python utilities.Usagepoetryaddoutcome-utilsCacheTo add cache to a modulefromoutcome.utilsimportcachecache_settings={'<your_prefix>.expiration':300,# Default'<your_prefix>.backend':'memory',# Default}region=cache.get_cache_region()cache.configure_cache_region(region,settings=cache_settings,prefix='<your_prefix>')Then add to the functions to cache:@region.cache_on_arguments()deffunc_to_cache():...Or for async functions:@region.cache_on_arguments()@cache.cache_asyncasyncdefasync_func_to_cache():...To have the cache persist on disk, specify the pathfrompathlibimportPathcache_settings={...'<your_prefix>.cache_path':f'{Path.home()}/.cache/example_path/cache.pkl'',...}DevelopmentRemember to run./pre-commit.shwhen you clone the repository.
Package: outdated
outdatedThis is a mini-library which, given a package name and a version, checks if it's the latest version available on PyPI.To install:pip install outdatedQuickstart:from outdated import warn_if_outdated

warn_if_outdated('my-package-name', '1.2.3')This will:Show a warning if the given version is not the latest. The warning includes the package name, the given version, and the latest version.Perform the check in a background thread (so it doesn't delay anything)Make at most one HTTP call (unless there is an HTTP error, in which case it will try 3 times) to the PyPI server for that specific packageCache the result of the HTTP call on disk for 24 hoursShow a warning if any exception occurs during the checkThis willnotcheck what version is currently installed, it will only use the given version. Library authors must make sure that the version in theirsetup.pymatches the version here.The package name argument must be exactly the name used on PyPI, so that e.g.https://pypi.python.org/pypi/my-package-nameis a valid URL.Optional arguments:background(defaultTrue): run the check in a separate thread. Set toFalseto run immediately.raise_exceptions(default:False): ifTrue, allow exceptions to bubble to the top. Otherwise, show a warning including the exception message. IfbackgroundisTrueand this isTruethen this will result in a full traceback showing but the process continuing.Lower level APIfrom outdated import check_outdated

is_outdated, latest_version = check_outdated('my-package-name', '1.2.3')is_outdatedis a boolean which is True if the given version is earlier than the latest version, which is the stringlatest_version.Optional arguments:repository_url(defaulthttps://pypi.python.org/pypi/%s/json): a%style format string to use a different repository PyPI repository URL, e.g. test.pypi.org or a private repository. The string is formatted with the package name.This still makes the HTTP call with retries and caches the result on disk. It doesn't use a separate thread or emit any warnings (unless there is an exception specifically while using the cache, in which case the check will be done without the cache).Additional configurationTo disable all warnings from this library, set the environment variableOUTDATED_IGNOREto any non-empty value.To always raise exceptions instead of converting them to warnings (both in general inwarn_if_outdatedand more specifically when there's a caching problem) set the environment variableOUTDATED_RAISE_EXCEPTION=1.The warnings are also categorised so that you can easily control them with standardwarning filters. The classes arehereand can be imported directly from theoutdatedmodule.PerformanceThis library works by fetching a URL such asthis- the time it takes to visit that link is essentially the speed of the library. This is much faster than the commandpip list --outdatedor any equivalent code.
Package: outdoorsy
Outdoorsy Command-Line ToolIntroductionA demo command line tool for displaying information from a comma or pipe delimited file.FeaturesUse as command-line tool interactively or by passing argumentsCreates a local SQL Lite Database for storing filesDatabase is created from the running directory or optionally a specified flagView database in a table format from the command-lineSort by "Name" or "Vehicle Type" columns (from sample files)InstallationGrab a copy of the code with pip:pipinstalloutdoorsyUsageoutdoorsy can be used to extract info from a Comma or Pipe delimited file in two ways:Command line/Terminal tool ran interactivelyoutdoorsyCommand line/Terminal tool ran with argumentsoutdoorsy -h1. Command Line/Terminal tooloutdoorsyRun outdoorsy -h to see the help output:outdoorsy-husage:usage:outdoorsy[-h][-fFILE][-d{comma,pipe}][-dbDBPATH][-v][-s{name,vehicle_type}][--version]Outdoorsy Command Line tool for displaying Outdoorsy user information.Argumentsoptions:
  -h, --help            show this help message and exit
  --version             show program's version number and exit

options - Upload a new file.:
  -f FILE, --file FILE  Full path to file
  -d {comma,pipe}, --delimiter {comma,pipe}
                        File's delimiter
  -db DBPATH, --dbpath DBPATH
                        Path to create database. Defaults to current directory

options - View and Sort data:
  -v, --view            View the Outdoorsy Customer Table.
  -s {name,vehicle_type}, --sort {name,vehicle_type}
                        Sort the database table by the Outdoorsy Customer's Fullname or Vehicle TypeExamplesUpload CSV file to databaseoutdoorsy-fC:\folder\file.csv-dcommaUpload Pipe delimited file to databaseoutdoorsy-fC:\folder\pipes.text-dpipeUpload Pipe delimited file to database created at specified pathoutdoorsy-fC:\folder\pipes.text-dpipe-dbC:\database\View data that has previously been uploaded to the databaseoutdoorsy-vView data that has previously been uploaded to the database at specified pathoutdoorsy-v-dbC:\database\View data sorted by Vehicle Typeoutdoorsy-v-svehicle_typeView data sorted by nameoutdoorsy-v-snameFuture EnhancementsUpdate --dbpath argument to --dbdir to make it clear the user needs to specify the directoryAdd additional testsAdd logic to handle duplicate database entriesAdd the ability to sort by any columnDepending on customer needs, add support for different headers and file types (outside of comma or pipe delimited)Convert to click library (currently using argparse)Build CI/CD pipeline for releases using GitHub ActionsOptimize the logic for argparse and interactive menu so that it's more efficient and avoid duplicates in codeMove the default used for db_path from the database functions to the argparse argument.
This would allow efficiency gains in argparse and when running interactively since a dbpath would always be specifiedLicenseThis program is licensed with anMIT License.
Package: outdpik
outdpik: Fundamental toolkit for outlier analysis and visualizationWhat is it?Outdpik is an open source Python package that provides different methods for outlier detection.
It aims to be the fundamental high-level package for this purpose.
Additionally, it offers visualization methods for the outlier analysis.Main FeaturesHere are just a few of the things that outdpik does well:It supports numpy arrays and pandas dataframesMultiple outlier detection techniques that can be combinedPowerful visualizationsFlexible at including one or more columns for the analysisWhere to get itThe source code is currently hosted on GitHub at:https://github.com/DanielPuentee/outdpikInstaller for the latest released version is available at thePython
Package Index (PyPI)# PyPIpipinstalloutdpikHow to use outdpikExamples of configuring and running outpdik:importoutpdikasoutdpoutdp=outdp()We proceed to detect outliers returning a dictionary of numeric features and the outliers instances:outliers_dict=outdp.outliers(df=df,cols="all")Plotting advantages:outdp.plot_outliers(df=df,col="x")Dependenciespandas - Provides fast, flexible, and expressive data structures designed to make working with "relational" or "labeled" data both easy and intuitiveNumPy - Adds support for large, multi-dimensional arrays, matrices and high-level mathematical functions to operate on these arraysSciPy - Includes modules for statistics, optimization, integration, linear algebra, Fourier transforms, signal and image processing, ODE solvers, and morematplotlib - Comprehensive library for creating static, animated, and interactive visualizations in Pythonseaborn - Provides a high-level interface for drawing attractive statistical graphicsLicenseThis project is licensed under the terms of theGNU- see the LICENSE file for details.DocumentationThe official documentation is hosted on:https://outdpik.readthedocs.io/en/latest/DevelopmentWant to contribute? Great!
Open a discussion in Github in this repo and we will answer as soon as possible.
Package: outernet-metadata
This package contains tools for working with Outernet metadata.PrerequisitesBefore you can use the scripts in this package, you will needPython2.7.x or
3.4.x or newer installed. Depending on the platform, you will also need to
installpip. In some cases these are installed with Python.You will also need to be familiar with the command consoles (Command Prompt,
terminals, etc). You will also need an editor. If you are on Windows, avoid
using Notepad. Instead installSublimeTextor any of the other more
fully-featured editors.InstallingTo install this package, use pip. In your command console type the following:pip install outernet-metadataFor command line tools, conz is also required, but it is not installed
automatically to allow outernet-metadata’s use as a library. To install conz:pip install conzGetting startedPlease refer to theContent packaging HOWTOto get started.About Outernet and Outernet contentOuternetis a data broadcast service with a goal of universal uncensored
information disemination (primarily) among the population without Internet
access.Outernet broadcasts content from the web packaged in a ZIP file that contains
metadata about the content. This package provides functionality for working
with the metadata.ScriptsThis package contains two scripts (when installed using setuptools/pip). These
are:metacheckmetagenimgcountPlease run each with-hswitch to see usage notes.About the metadata specificationOfficial Outernet metadata specification is maintained as part of this
repository. You will find them in thecontent-metadata-specification.rstfile.
Package: outerspace
outerspaceAn interactive widget for Jupyter notebooks to explore the parameters of t-SNE.InstallationpipinstallouterspaceAdditionally, if you usejupyter notebook:jupyternbextensionenable--pywidgetsnbextension... or forjupyter lab:jupyterlabextensioninstall@jupyter-widgets/jupyterlab-manager
jupyterlabextensioninstall@bokeh/jupyter_bokehUsageRun t-SNE on the digits data set (see result in the image above):fromouterspaceimporttsne_playgroundfromsklearn.datasetsimportload_digitsdigits=load_digits()X,y=digits.data,digits.targettsne_playground(X,y)Show the actual digit images in a tooltip:fromouterspaceimporttsne_playground,array2d_to_html_imgfromsklearn.datasetsimportload_digitsdigits=load_digits()X,y,images=digits.data,digits.target,digits.imagesimages=256-images*16# convert range and invertimages=images.clip(0,255)# clip values at 255images=images.astype('uint8')# convert to uint8images=[array2d_to_html_img(image,resize=(32,32))forimageinimages]# convert to HTML imagestsne_playground(X,y,additional_columns=dict(images=images),tooltips='@images{safe}')# safe = don't escape HTMLFurther examplesEvaluating the chemical space of a set of molecules (with molecule images as tooltip):fromouterspaceimporttsne_playground,pil_to_html_imgfromrdkit.ChemimportSDMolSupplier,Draw,AllChemimportrequestsimportnumpyasnpurl=('https://raw.githubusercontent.com/rdkit/rdkit''/Release_2020_03/Docs/Book/data/solubility.test.sdf')response=requests.get(url)supplier=SDMolSupplier()supplier.SetData(response.text)ms=[mforminsupplier]X=np.array([list(AllChem.GetMACCSKeysFingerprint(m))forminms])y=[m.GetProp('SOL_classification')forminms]images=[pil_to_html_img(Draw.MolToImage(m,size=(150,150)))forminms]tsne_playground(X,y,additional_columns=dict(images=images),tooltips='@images{safe}')
Package: outerspace-apizr
OuterSpace ApizrOuterSpace Apizris a groundbreaking open-source tool that is set to redefine the way data engineers interact with notebooks. It is specifically designed to transform notebooks into powerful, containerized APIs, seamlessly bridging the gap between data analysis and application development.In the world of data engineering, notebooks are an essential tool for exploratory data analysis, prototyping, and sharing results. However, turning these notebooks into production-ready applications can be a challenging task. This is where OuterSpace Apizr comes in. It allows you to convert your notebooks into robust, containerized APIs, enabling you to integrate your data analysis and computations into larger systems and applications with ease.The containerization of APIs ensures that they are portable, scalable, and easy to deploy, making them an ideal solution for data engineers looking to streamline their workflows and increase efficiency.OuterSpace Apizr is built with simplicity, efficiency, and the specific needs of data engineers in mind. It's easy to set up, user-friendly, and requires minimal configuration. Whether you're a seasoned data engineer or a newcomer to the field, OuterSpace Apizr is designed to streamline your workflow and increase productivity.InstallationOuterSpace Apizr is now easily installable via pip. To install, simply run:pipinstallouterspace-apizrOnce installed, you can start using OuterSpace Apizr to transform your notebooks and enhance your data engineering workflows.
Package: outfancy
outfancyTable printing and Line plotting in TerminalDemonstrationhttp://showterm.io/42f0bfa286232758acf18http://showterm.io/5a31927cbfdc37e116f8dwhat is it?Outfancy is a Python3.11+ library to print tables in Terminal. It's a quick way to visualize data when you don't have a GUI and can be integrated easily in your programs. It's written in Python 3.6 and can quickly be installed anywhere using pip.installationinstall with pippip install outfancyfeaturesQuick printing of tables.LineChart printing with linear interpolation.customize the separator used, width, priority of printing for each column.rearrange the columns in real time.Add labels above the table (can be autogenerated).Do Oneline printing, useful for real-time applications (report in screen function).Add colors to the field of the tables.usageIn the interpreterTable.import outfancy.table
table = outfancy.table.Table()
dataset = [(1, 'Marie'), (2, 'Joseph')]
print(table.render(dataset))Chart.import outfancy.chart

from math import sin
line_chart = outfancy.chart.LineChart()

dataset = [(i, sin(i)) for i in range(10)]
line_chart.plot(dataset)
print(line_chart.render(color=True))To do (Colaboration is welcome)Translate code to english. (Translated) (the translation need revision from a native english speaker (I speak spanish).Improve y_interpolation function on outfancy.chart.LineChart
Maybe add more kinds of charts on outfancy.chart.
Maybe on outfancy.table:Checking system on width parameter.Option to cancel the automatical checking of width parameter.Othershttps://gist.github.com/carlosplanchon/986c7c11a932a7206bb3(Funny demo with colors)Experimental (Line Chart)- http://showterm.io/80074a1806e78205339d6
Package: outfit418-backup-ratting
Outfit418 Backup RattingInstallationpip install outfit418-backup-rattingAddoutfit418_backup_ratting(note the underscore) to yourINSTALLED_APPSRun migrationsRestart AllianceAuthTasksAdd to local.pyCELERYBEAT_SCHEDULE['outfit418_update_fake_chars']={'task':'outfit418_backup_ratting.tasks.update_fake_users','schedule':crontab(minute=0,hour=0),}