Saravanan666/pypi-org huggingface dataset:
Package: datarobot-mlops
DataRobot MLOps metrics reporting libraryThis is the Python version of the DataRobot MLOps reporting SDK.
This library enables remote reporting of MLOps metrics back to DataRobot for
monitoring.More information on DataRobot MLOps reporting library can be found here:https://docs.datarobot.com/en/docs/mlops/deployment/mlops-agent/index.html.InstallationInstall the MLOps reporting SDK with minimal dependencies.
This means that only thefilesystemspooler typewill be available.pipinstalldatarobot-mlopsBy installing additional dependencies, you can leverage these additional spooler types:rabbitmq- Installs dependencies for therabbitmqspooler type.google- Installs dependencies for thepubsubspooler type.kafka- Installs dependencies for thekafkaspooler type.azure- Installs dependencies that enable Azure Active Directory authentication for thekafkaspooler type.aws- Installs dependencies for thesqsspooler type.You can install these extra dependencies usingpip, for example:pipinstall'datarobot-mlops[rabbitmq]'You can also install multiple sets of dependencies at once, for example:pipinstall'datarobot-mlops[kafka,azure]'Supported Python VersionsPython >= 3.7The last version of this library compatible with Python 2.7 isdatarobot-mlops~=9.0.
Package: datarobot-mlops-connected-client
DataRobot MLOps Connected client (mlops-cli)This is the Python client used to communicate with the
DataRobot MLOps service. It can be used to upload datasets,
create and deploy model packages, report predictions files, etc.Installation$pipinstalldatarobot-mlops-connected-clientDocumentationOnce installed, thehelpparameter provides detailed usage information.$mlops-cli--help
Package: datarobot-mlops-stats-aggregator
MLOps Stats Aggregation Library (Python)UsageThe Python library for MLOps stats aggregation has two entry points:aggregate_statsTheaggregate_statsfunction inaggregation.pyis the primary entry point into the library. This function accepts dataframes of raw features and/or predictions and
aggregates statistics suitable to be submitted to DataRobot MLOps for deployment monitoring. In order to use this function,
the types of each tracked feature must be specified, and certain feature types (e.g. currency) require additional format
information. See the docstring and type declarations ofaggregate_statsfor details about specific requirements.merge_statsThemerge_statsfunction defined inmerging.pyis used to merge together the outputs of calls toaggregate_stats. It returns a value with the same shape as that
returned byaggregate_stats. Merging stats makes sense (for example) in the MLOps Tracking Agent, which will buffer
stats aggregated by the MLOps Reporting Library. The agent can merge those buffered stats before sending them in a
single payload to DataRobot MLOps.
Package: datarobot-ts-helpers
datarobot_ts_helpers packageA library of helper scripts to support complex time-series modeling using DataRobot AutoTS softwareAuthorsJustin Swansburg, Jarred Bultema, Jess LinDescriptionThe modeling of large scale time-series problems is possible directly within DataRobot software via the GUI or via R or Python modeling APIs. While the software is capable of modeling up to 1 million series per project and applying state of the art modeling techniques, often there is motivation to model aspects of a data science problem across multiple DataRobot projects. Motivation for this may include a desire to externally cluster similar series, apply different data manipulations or corrections, utilize different data sources, apply different differencing strategies, utilize different Feature Derivation Windows, or investigate different Forecast Distance ranges. Regardless of the reasons, internally we have found that performance can often be improved on large or complex time-series use cases by breaking a large, challenging problem into smaller pieces and modeling each of those pieces separately.This is feasible directly using the R or Python modeling APIs, but the challenge quickly becomes one of software engineering and logistics to manage, compare, and store outputs of numerous projects that are part of a single use-case. The purpose of the ts_helpers package is to automate this logistical challenge and allow the DataRobot user to focus on applying different approaches to solve their use case, rather than focusing on the less interesting aspects of the problem.ContentsThis python package contains numerous functions to enable the user to easily scale from one to thousands of DataRobot projects starting with data preparation and continuing through modeling, model evaluation, iterative performance improvements, visualization of results, deployment of models, and serving ongoing predictions.A detailed Table of Contents describes all functions present and the documentation string for each function. Detailed tutorials are also available to demonstrate the use of this ts_helpers package and all of the functions contained within.
Package: dataroid
InstallationpipinstalldataroidUsage ExamplefromdataroidimportBotimportpandasaspddata=pd.read_csv("shopping.csv")model=Bot(data)model.generate(5)Dependenciespandas - A Python package that provides fast, flexible, and expressive data structures designed to make working with "relational" or "labeled" data both easy and intuitive.ctgan - CTGAN is a collection of Deep Learning based synthetic data generators for single table data, which are able to learn from real data and generate synthetic data with high fidelity.CitationLei Xu, Maria Skoularidou, Alfredo Cuesta-Infante, Kalyan Veeramachaneni.Modeling Tabular data using Conditional GAN. NeurIPS, 2019.@inproceedings{ctgan,
  title={Modeling Tabular data using Conditional GAN},
  author={Xu, Lei and Skoularidou, Maria and Cuesta-Infante, Alfredo and Veeramachaneni, Kalyan},
  booktitle={Advances in Neural Information Processing Systems},
  year={2019}}
Package: datar-pandas
datar-pandasThe pandas backend fordatar.Installationpipinstall-Udatar-pandas# orpipinstall-Udatar[pandas]Usagefromdatarimportf# Without the backend: NotImplementedByCurrentBackendErrorfromdatar.dataimportirisfromdatar.dplyrimportmutate# Without the backend: NotImplementedByCurrentBackendErroriris>>mutate(sepal_ratio=f.Sepal_Width/f.Sepal_Length)
Package: datarray
Scientists, engineers, mathematicians and statisticians don’t just work with
matrices; they often work with structured data, just like you’d find in a
table. However, functionality for this is missing from Numpy, and there are
efforts to create something to fill the void.  This is one of those efforts.WarningThis code is currently experimental, and its APIwillchange!  It is meant
to be a place for the community to understand and develop the right
semantics and have a prototype implementation that will ultimately
(hopefully) be folded back into Numpy.Datarray provides a subclass of Numpy ndarrays that support:individual dimensions (axes) being labeled with meaningful descriptionslabeled ‘ticks’ along each axisindexing and slicing by named axisindexing on any axis with the tick labels instead of only integersreduction operations (like .sum, .mean, etc) support named axis arguments
instead of only integer indices.Prior ArtIn no particular order:xray- very close in spirit to this
package, xray implements named ND array axes and tick labels.  It integrates
with (and depends on) Pandas;pandasis based around a number of
DataFrame-esque datatypes.Tabularimplements a
spreadsheet-inspired datatype, with rows/columns, csv/etc. IO, and fancy
tabular operations.scikits.statsmodelssounded as
though it had some features we’d like to eventually see implemented on top of
something such as datarray, andSkipperseemed pretty interested in something like this himself.scikits.timeseriesalso has a
time-series-specific object that’s somewhat reminiscent of labeled arrays.pandasis based around a number of
DataFrame-esque datatypes.pydataframeis supposed to be a
clone of R’s data.frame.larry, or “labeled array,” often comes up
in discussions alongside pandas.divisiincludes labeled sparse and
dense arrays.pymvpaprovides Dataset class
encapsulating the data together with matching in length sets of attributes
for the first two (samples and features) dimensions.  Dataset is not a
subclass of numpy array to allow other data structures (e.g. sparse
matrices).ptsasubclasses
ndarray to provide attributes per dimensions aiming to ease slicing/indexing
given the values of the axis attributesProject GoalsGet something akin to this in the numpy core;Stick to basic functionality such that projects like scikits.statsmodels can
use it as a base datatype;Make an interface that allows for simple, pretty manipulation that doesn’t
introduce confusion;Oh, and make sure that the base numpy array is still accessible.CodeYou can find our sources and single-click downloads:Main repositoryon Github;Documentationfor the current release;Download thecurrent trunkas a tar/zip file;Downloads of allavailable releases.The latest released version is always available frompypi.SupportPlease put up issues on thedatarray issue tracker.
Package: data-rte-python-api
data-rte-python-apiis a Python API wrapper for theAPIs of the RTE.InstallationThe library can be installed usingpip(the library is not published on PyPI yet):pipinstalldata-rte-python-apiUsageYou will have to register an application to get aclient_idandclient_secretbefore using any of the APIs.fromdatetimeimportdatetimefromdatarteapiimportBigSubstations,BaseAPIExceptionclient=BigSubstations(client_id="your_client_id",client_secret="your_client_secret")try:apiresponse=client.get_pds_data(start_date=datetime.fromisoformat("2017-09-01T12:00:00"),end_date=datetime.fromisoformat("2017-09-01T23:00:00"))exceptBaseAPIExceptionase:# Handle the exceptionprint(apiresponse.data,apiresponse.headers)Currently, only the APIs working with OAuth are available.Date entriesDepending on the API you are using, date timezones are handled differently. If all timezones are supported by the API server, the datetime will be used as is.
If only UTC is supported, timezone aware dates will be converted to UTC. For unware dates, local timezone is used before being converted to UTC.For more details, refer to the corresponding API documentation.
Package: datarum
Datárum is a small python library to convert Gregorian dates to Wending,
an Old English variant on theFrench Republican calendar, for use in
various projects. Documentation is available onReadTheDocs.The leap years are calculated according to the Romme rule, which uses
the 4-100-400 rule from the Gregorian calendar (a leap day becoming an
extra 6th Wending day).Hwý?I appreciate the political impulse behind the French Republican
calendar, as well as its more rational system (12 months of 30 days,
plus 5/6 celebratory days at the end of the year). However, I like the
aesthetics of Old English more than the original french names for the
months, so I’ve attempted to rougly translate or otherwise approximate
the Old English equivalents.TranslationFrenchOld EnglishTranslationAutumnVendémiaireHærfestHarvest, autumnBrumaireMistMist, fogFrimaireForstFrostWinterNivôseSnáwSnowPluviôseRegRainVentôseWindWindSpringGerminalSǽdSeedFloréalBlóstmBlossom, flowerPrairialMǽdlandMeadow-landSummerMessidorRípReaping, harvestThermidorHátHeatFructidorWæstmGrowth, produce, fruitComplementarySansculottidesWendingA turning round, revolution
Package: datarunner
datarunnerA simple data workflow runner that helps you write better ETL scripts using reusable code pieces.Quick Start TutorialInstall using pip:pip install datarunnerThen write a few steps (functions, classes, etc) that can be called, pass todatarunner.Workflow, and call run():fromdatarunnerimportWorkflow,Stepdefsetup():print('Ready to go!')defextract():return'data'deftransform(data):returndata+' using reusable code pieces, like Lego.'classLoad(Step):""" Sub-class Step to customize the callable """def__init__(self,destination):super().__init__()self.destination=destinationdef__str__(self):returnf'Load("{self.destination}")'defrun(self,data):print(f'Loading{data}')flow=Workflow(setup,table_name1=[extract,transform,Load('example')])flow.run()It produces the following output:setup
Ready to go!

table_name1
--------------------------------------------------------------------------------
extract
>> transform
>> Load("example")
Loading data using reusable code pieces, like Lego.We can also use>>operator to convey the same flow:flow=(Workflow()>>setup<<'table_name1'>>extract>>transform>>Load('example'))flow.run()To make the workflow more flexible (e.g. write to different dataset), use templates to provide some values at run time:classLoad(Step):TEMPLATE_ATTRS=['destination']""" Sub-class Step to customize the callable """def__init__(self,destination):super().__init__()self.destination=destinationdef__str__(self):returnf'Load("{self.destination}")'defrun(self,data):print(f'Loading{data}')flow=Workflow()>>extract>>transform>>Load('{dataset}.table_name1')flow.run(dataset='staging')It produces the following output:extract
>> transform
>> Load("staging.table_name1")
Loading data using reusable code pieces, like Lego.And finally, to test the workflow:def test_flow():
   assert """\
extract
>> transform
>> Load("{dataset}.table_name1")""" == str(flow)Workflow LayoutA recommended file layout for your ETL package:my_package/steps/__init__.py            # Generic / common steps
my_package/steps/bigquery.py            # Group of steps for a specific service, like BigQuery.
my_package/datasource1.py               # ETL workflow for a single data source with steps specifc for the source
my_package/datasource2.py               # ETL workflow for another data sourceInside ofdatasource*.py, it should defineflow = Workflow(…), but not run. From your ETL script, it should callflow.run()to run the workflow. This ensures the workflow is properly constructed when imported and can be used for
testing without running it.Links & Contact InfoPyPI Package:https://pypi.org/project/datarunner/GitHub Source:https://github.com/maxzheng/datarunnerReport Issues/Bugs:https://github.com/maxzheng/datarunner/issuesCreator:https://www.linkedin.com/in/maxzheng
Package: datasafe
DataSafe - Utilities for data encryption / decryptionTable of contentsInstallationDockerCommand-lineEncryptDecryptPythonPandasFilesLicenseContactInstallationpipinstalldatasafeDockergitclone--depth1https://github.com/StephenRicher/datasafe.gitcddatasafe/
dockerbuild-tdatasafe.
dockerrundatasafe--helpCommand-lineEncryptdatasafeencryptdata.csv>data.encryptedDecryptdatasafedecryptdata.encrypted>data.decrypted.csvPythondatasafecan be imported as a python module to encrypt and decrypt files.PandasIf a Pandas DataFrame is provided todatasafe.encryptthen it will be encrypted in.parquetformat.
Following decryption, an in-memory buffer is returned which should be passed topd.read_parquetto recover the dataframe and datatypes.importpandasaspdfromdatasafeimportencrypt,decryptdf=pd.DataFrame({'A':[1,2,3],'B':['dog','cat','bat']})encrypt(df,'df-encrypted.pq')df=pd.read_parquet(decrypt('df-encrypted.pq'))FilesThe command line functionality can also be achieved within Python.
In addition thedatasafe.decryptfunction returns an in-memory buffer which can be read directly.Encrypt and write encrypted data to fileimportpandasaspdfromdatasafeimportencrypt,decryptwithopen('data.encrypted','wb')asfh:fh.write(encrypt('data.csv'))Decrypt and write decrypted data to filewithopen('data.decrypted.csv','w')asfh:fh.write(decrypt('data.encrypted').getvalue())Decrypt and read in-memory buffer to Pandasdf=pd.read_csv(decrypt('data.encrypted'))LicenseDistributed under the MIT License.SeeLICENSEfor more information.ContactIf you have any other questions please contact the authorStephen Richeratstephen.richer@proton.me
Package: datasaku
datasaku ReadmeThe package contains several function to make analysis easier. Several function included in the packages are:datasaku.calendar= Calendar operation in pandas.datasaku.geo= Manipulation of geolocation data based on geopandas.datasaku.google= Connection to google environment such as google sheets.datasaku.nlp= NLP related module such as fuzzy matching.datasaku.pandas= Function related to pandas.datasaku.presto= Connection to Presto.datasaku.s3= API connection to S3.datasaku.snowflake= Function to make connection to Snowflake.datasaku.starburst= Function to do operation in Starburst.datasaku.viz= Function to do advance visualization such as sankey.There are pre-requisite to connect to google as described here:(wip)InstalationSince the package will consist of geo related package so installing gdal is necessary (be patient, takes time)brew install gdalInstall the datasaku package using pippip install --upgrade --no-deps --force-reinstall datasaku
Package: data-samples-printer
Data Samples PrinterDocumentation:https://ernestum.github.io/data-samples-printerSource Code:https://github.com/ernestum/data-samples-printerPyPI:https://pypi.org/project/data-samples-printer/Don't be just mean and standart, print histograms as unicode instead!Installationpipinstalldata-samples-printerBasic Usageimportdata_samples_printerasdspimportnumpyasnps1=np.random.normal(size=100)s2=np.random.normal(size=100,scale=0.2)# Plain printingdsp.print(s1)>▁▃▁▃▁▃▃▅▇▅█▄▄▄▇▃▃█▄▅▇▄▃▃▁█▅█▁▃▃▁▃▁▁# Printing multiple samples aligns their rangedsp.print(s1,s2)>▁▃▁▃▁▃▃▅▇▅█▄▄▄▇▃▃█▄▅▇▄▃▃▁█▅█▁▃▃▁▃▁▁>▁▂▃█▄▅▃▂▁# Printing with labelsdsp.print(normal=s1,squeezed=s2)>▁▃▁▃▁▃▃▅▇▅█▄▄▄▇▃▃█▄▅▇▄▃▃▁█▅█▁▃▃▁▃▁▁normal>▁▂▃█▄▅▃▂▁squeezed# Pretty printingdsp.pprint(s1,s2)>▂▂▁▁▁▂▄▃▁▁▂▂▂▄▃▂█▃▃▂▃▂▂▂▁▃▂▄▃▂▁▂▁▁▁▂▁▁0.00±1.00>▁▂▃▆█▅▆▄▁0.04±0.20dsp.mprint(normal=s1,squeezed=s2)>dist|mean|std|name>-----|------|-----|----->`▕▁▂▁▁▁▁▁▃▁▂▆▂▁▅▅▅█▂▅▃▅█▃▇▆▂▂▂▂▂▂▅▃▁▁▁▂▁▏`|-0.04|±0.85|normal>`▕▁▁▄▃█▆█▆▂▂▏`|0.01|±0.19|squeezed>`▕-1.932.41▏`|renders as:distmeanstdname▕▁ ▂▁▁▁▁▁▃▁ ▂▆▂▁▅▅▅█▂▅▃▅█▃▇▆▂▂▂▂▂▂▅▃▁ ▁     ▁   ▂ ▁▏-0.04±0.85normal▕                ▁ ▁▄▃█▆█▆▂▂                       ▏0.01±0.19squeezed▕-1.93                                         2.41▏DevelopmentClone this repositoryRequirements:PoetryPython 3.7+Create a virtual environment and install the dependenciespoetryinstallActivate the virtual environmentpoetryshellTestingpytestDocumentationThe documentation is automatically generated from the content of thedocs directoryand from the docstrings
of the public signatures of the source code. The documentation is updated and published as aGithub project pageautomatically as part each release.ReleasingTrigger theDraft release workflow(pressRun workflow). This will update the changelog & version and create a GitHub release which is inDraftstate.Find the draft release from theGitHub releasesand publish it. When
a release is published, it'll triggerreleaseworkflow which creates PyPI
release and deploys updated documentation.Pre-commitPre-commit hooks run all the auto-formatters (e.g.black,isort), linters (e.g.mypy,flake8), and other quality
checks to make sure the changeset is in good shape before a commit/push happens.You can install the hooks with (runs for each commit):pre-commitinstallOr if you want them to run only for each push:pre-commitinstall-tpre-pushOr if you want e.g. want to run all checks manually for all files:pre-commitrun--all-filesThis project was generated using thewolt-python-package-cookiecuttertemplate.
Package: dataSaver
DataSaverUtility to save data to cvs as an easy (and very basic) to read and use alternative to tensorboard.UsagefromdataSaverimportDataSaverdataSaver=DataSaver('./somedir/filename/')# creates a file in csv format, where the keys of the dictionary are the column names and the values of the first row are the values associated with each keydataSaver.add({'ephoch':10,,'iter':200,'learningRate':0.0001,,'loss':10324}# The first call fixes the columns and only the keys that where present the first time add was called will be addeddataSaver.add({'ephoch':10,,'bananass':10324,'iter':200,'learningRate':0.0001,,'loss':10324,'bananass':10324})# collect all data in an internal array dataSaver.cacheArraydataSaver.cache({....})# Save the data collected by cache to file and empty cachedataSaver.dumpCache()
Package: datascale
datascaleFunctions for automatic scaling of matplotlib line width, marker width, fontsize, and resolution to dataInstallationpipinstalldatascaleorpipinstallgit+https://github.com/benkrichman/datascale.git@mainMain Functionsplotdatasize()Scale line width, marker width, or fontsize for plots to correspond directly to the scale of data on either/both plot axes. For more detail see help output:help(datascale.plotdatasize)To reproduce this image view test() in datascale.py or usedatascale.test()plotdatadpi()Scale dpi of output image to produce a certain number of points per data unit on either/both plot axis/axes. Useful for plots that need a certain amount of detail per axis unit (e.g. geographic projections). For more detail see help output:help(datascale.plotdatadpi)To reproduce this image view test() in datascale.py or usedatascale.test()
Package: dataschema
Basic validation for Python data structures in a mostly declarative
form (there is an escape hatch in “extraValidation” callables).Validation errors are reported as both a path within the data
structure (sequence of indices or keys) and a descriptive message
(string).Typical usage:data = json.load(some_file) # or pickle, or ...
errors = dataschema.Validator(my_schema).validate(data)
if errors:
    for path, message in errors:
        # Report error `message` at path `path`.
else:
    # Any data access or application-specific validation can now
    # rely on properties of my_schema (e.g. minimum number of
    # elements in a sequence, data types of elements, presence of
    # certain keys in a dict, etc.).See the unit tests for schema examples.There are a few limitations (only string keys for any dictionaries in
data) and a more fully Pythonic validator might focus on interfaces
and abstract base classes over concrete types.  However, dataschema is
a great improvement over ad hoc validation code for many uses today.
Package: dataschool
dataschoolFull kit to analyse datas (data transformation, clustering, graphs)Free software: MIT licenseDocumentation:https://dataschool.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-10-05)First release on PyPI.0.2.0 (2020-11-12)Update new version after refactor
Package: datasci
datasciInstall from PyPI:pipinstalldatasciInstall in development mode:pipinstall-e.FeaturesJupyter notebook initialization%run -m datasci.notebook.initPandas helpersimportpandasaspddf=pd.DataFrame(...)fromdatasci.pandasimportdrop_na_columns,drop_uninformative_columnsdf_without_na=drop_na_columns(df)df_informative=drop_uninformative_columns(df)# or, all-together:df=pd.DataFrame(...).pipe(drop_na_columns).pipe(drop_uninformative_columns)Testingpythonsetup.pytestLicenseCopyright 2018–2020 Christopher Brown.MIT Licensed.
Package: data-science-bowl-2019
data_science_bowl_2019The notebooks for the competition Data Science Bowl 2019I join this competitiondata-science-bowl-2019,
which ends on January 15, 2020. For the data feature, I do some work on
the series features, using word2vec, LDA and node2vec.wide and
deepnode2vecLDAThe baseline feature engineering I forked from Hosseinali (2019).
However, it helps me focus on series features. Also, I use LTSM model to
elaborate series features, I forked from Grecnik (2019).Grecnik. 2019. “Bowl Lstm Prediction | Kaggle.” Kaggle. 2019.https://www.kaggle.com/nikitagrec/bowl-lstm-prediction.Hosseinali, Massoud. 2019. “A New Baseline for Dsb 2019 - Catboost
Model.” Kaggle. 2019.https://www.kaggle.com/mhviraf/a-new-baseline-for-dsb-2019-catboost-model.Installpip install data_science_bowl_2019How to useSee demo.