Saravanan666/pypi-org huggingface dataset:
Package: data-records
Data RecordsIn certain Functional languages there is a concept of Records. They are a Product Data Type of immutable data that
has typed attributes.GoalsThe following are the goals and the "north star" for design during the development of this project:Ease Of UseSimple InterfaceDoes the obvious thing in most casesImmutabilityFollow Immutability Patterns such as replace and pattern matchingSafetyInclude Type Coercion Where PossibleGuarantee that a record has the resulting typesThrow Warning when it is implemented IncorrectlyMotivationEnforced TypingI love@dataclass, and was ecstatic when it was added to python. However certain things like:>>>fromdataclassesimportdataclass,field>>>@dataclass...classFoo:...bar:str...baz:int>>>Foo(1,2)Foo(bar=1,baz=2)is not what I would expect when coming from other typed languages. In statically typed languages, this should throw an
error becausebarshould be a string. In languages with type coercion, I would expect thatbarwould be"1". The default
behavior of dataclasses here does neither, and if I were to use this dataclass somewhere that expected bar to be a string
it would fail with a runtime exception; exactly what the types were supposed to help prevent.>>>fromdata_recordsimportdatarecord>>>@datarecord...classFoo:...bar:str...baz:int>>>Foo(1,2)Foo(bar='1',baz=2)>>>Foo("a","b")Traceback(mostrecentcalllast):...ValueError:invalidliteralforint()withbase10:'b'Extraneous Field HandlingAnother Problem with dataclasses occurs when trying to pass in a dictionary that has more keys than are required for
creating a dataclass:>>>fromdataclassesimportdataclass>>>@dataclass...classFoo:...bar:str...baz:int>>>Foo(**{'bar':'test','baz':1,'other':'nothing'})Traceback(mostrecentcalllast):...TypeError:__init__()gotanunexpectedkeywordargument'other'This makes it hard to pull data records out of larger database calls or received data.>>>fromdata_recordsimportdatarecord>>>@datarecord...classFoo:...bar:str...baz:int>>>Foo(**{'bar':'test','baz':1,'other':'test'})Foo(bar='test',baz=1)>>>Foo.from_dict({'bar':'test','baz':1,'other':'test'})Foo(bar='test',baz=1)Immutable HandlingData records are immutable (much like frozen dataclasses) and the handling for such is builtin:>>>fromdata_recordsimportdatarecord>>>@datarecord...classFoo:...bar:str...baz:int...lat:float...long:float>>>example=Foo('test',2,65.1,-127.5)>>>example2=example.replace(bar='testing')>>>exampleFoo(bar='test',baz=2,lat=65.1,long=-127.5)>>>example2Foo(bar='testing',baz=2,lat=65.1,long=-127.5)>>>latitude,longitude=example.extract('lat','long')>>>latitude65.1
Package: data-reduction
InstanceSelectionInstanceSelection is a Python module for reducing number of instances in datasets used in classification problems.
The module is implemented as part of an engineering project.Instalationpip install data_reductionUsageData loading and preparationThe first step is to load and prepare data using DataPreparation:data = DataPreparation('iris')Instance selection with selected algoritmFor all algorithms required parameter is instance of DataPreparation. Then you can reduce instances and prepare raport.alg = DROP1(data, k=3)
    alg.reduce_instances()Creating raportAfter reduction with selected algorithm you can create raport:rap = Raport(data, alg.red_data, alg.red_lab)
    rap.print_raport(c_type = 'knn')Results of raporting=============
Classifier:   knn
=============
Raport for original dataset
Count of instances:  105
                 precision    recall  f1-score   support

    Iris-setosa     1.0000    1.0000    1.0000        19
Iris-versicolor     1.0000    1.0000    1.0000        13
 Iris-virginica     1.0000    1.0000    1.0000        13

       accuracy                         1.0000        45
      macro avg     1.0000    1.0000    1.0000        45
   weighted avg     1.0000    1.0000    1.0000        45

Cohen's Kappa: 1.00
===
Training time:  0.0008822999999997805
Predicting time:  0.003322799999999848

Raport for reduced dataset
Count of instances:  21
                 precision    recall  f1-score   support

    Iris-setosa     1.0000    1.0000    1.0000        19
Iris-versicolor     0.7647    1.0000    0.8667        13
 Iris-virginica     1.0000    0.6923    0.8182        13

       accuracy                         0.9111        45
      macro avg     0.9216    0.8974    0.8949        45
   weighted avg     0.9320    0.9111    0.9090        45

Cohen's Kappa: 0.86
===
Training time:  0.0006775000000001086
Predicting time:  0.0024793999999999095

Reduction factor: 80.00 %
Package: data-refinery
Data RefineryThe main goal of the library is perform a Transformation over a data
event. Supports a variety of functions typically used on machine
learning and AI.Development is oriented into a functional style avoiding side effects on
transformations.InstallationIn consolepip installdata-refineryorpython setup.py installfrom sources.Usage examplefromdatarefinery.TupleOperationsimportwrap,keep,substitutionfromdatarefinery.CombineOperationsimportsequentialx2=wrap(lambdax:x*2)operation=sequential(keep(["name"]),substitution(["value"],x2))(res,err)=operation({"name":"John","value":10})print(res)# {"name": "John", "value": 20}DocumentationVisit complete documentation atreadthedocs.io.CompatibilityPython: 3.5, 3.6ContributeFollow the steps on thehow to contributedocument.
Package: data-repo-client
&lt;details&gt;&lt;summary&gt;This document defines the REST API for the Terra Data Repository.&lt;/summary&gt; &lt;p&gt;Status: design in progressThere are a few top-level endpoints (besides some used by swagger):  * / - generated by swagger: swagger API page that provides this documentation and a live UI for submitting REST requests  * /status - provides the operational status of the service  * /configuration - provides the basic configuration and information about the service  * /api - is the authenticated and authorized Data Repository API  * /ga4gh/drs/v1 - is a transcription of the Data Repository Service API  The API endpoints are organized by interface. Each interface is separately versioned. &lt;p&gt;Notes on Naming&lt;p&gt; All of the reference items are suffixed with \&quot;Model\&quot;. Those names are used as the class names in the generated Java code. It is helpful to distinguish these model classes from other related classes, like the DAO classes and the operation classes. &lt;/details&gt;   # noqa: E501
Package: datareport
# ReporterThis tool helps in gathering and formatting of data into a report. The toolreporter.pybasically combines YAML data files with Jinja2-based
templates.  In this way simple markup versions of your report can be
produced. Together with a format converter like [Pandoc](http://pandoc.org)
the produced output can then be converted to various target formats (HTML,
PDF, …).To keep a good overview which data is acquired for different parts of the
report, it is probably a good step to automate the whole workflow with a
tool like [snakemake](https://snakemake.readthedocs.io/en/stable/) or other
make-like tools.# InstallThe fastest way to install datareport is to use your systems tools:pip install datareportTo use the latest test version check out the test.pypi server:pip install –index-urlhttps://test.pypi.org/simpledatareport## RequirementsAll required packages are listed inenvironment.yaml. In case you
installed datareport via a package management system like pip, anaconda,
miniconda, … all dependencies should already be installed automatically.# Getting StartedFor easing your first steps with datareport a small set of [documented
examples](examples/README.md) can be found in theexamples/folder. The
README file gives an overview and you can find the right place to start.## Further readingFor designing reports you need to know about the templating language and
since you will want to use some automation for the reporting process, also a
make-like tool is very helpful. Look at the excellentsnakemakefor that![Jinja2](http://jinja.pocoo.org/docs/2.10/) (→ [templating
language](http://jinja.pocoo.org/docs/2.10/templates/))[Snakemake](https://pypi.org/project/snakemake/) (→ [writing
rules](https://snakemake.readthedocs.io/en/stable/snakefiles/rules.html))As data inputs you can use different formats. For understanding the details
about each format you find a lot of information on the web, especially:YAML (→ [specification](http://yaml.org/spec/)) and the
[ruamel.yaml](https://yaml.readthedocs.io/en/latest/basicuse.html)
package.JSON (→ [specification](https://json.org/))# Developing datareportContributions are very welcome! Write issues for feature requests or
directly file a pull-request with your contribution and/or contact me
directly!## TestsThis project uses the [PyTest framework](https://docs.pytest.org/en/latest/)
with tests defined in the [tests/](tests/) sudirectory. It is added into the
setuptools config, so that it can be run withpython setup.py testThis automatically tests a temporarily packaged version.Alternatively you can runpytestmanually with all it [glory
details](https://docs.pytest.org/en/latest/usage.html).## ReleasesThe release workflow is mostly automated and is in the [release/](release/)
folder.
Package: data-report-tool
Start Bootstrap - SB Admin 2SB Admin 2is an open source admin dashboard theme forBootstrapcreated byStart Bootstrap.For the legacy Bootstrap 3 version of this theme, you can view thelast stable releaseof SB Admin 2 for Bootstrap 3.PreviewLaunch Live PreviewStatusDownload and InstallationTo begin using this template, choose one of the following options to get started:Download the latest release on Start BootstrapInstall via npm:npm i startbootstrap-sb-admin-2Clone the repo:git clone https://github.com/StartBootstrap/startbootstrap-sb-admin-2.gitFork, Clone, or Download on GitHubUsageAfter installation, runnpm installand then runnpm startwhich will open up a preview of the template in your default browser, watch for changes to core template files, and live reload the browser when changes are saved. You can view thegulpfile.jsto see which tasks are included with the dev environment.Gulp Tasksgulpthe default task that builds everythinggulp watchbrowserSync opens the project in your default browser and live reloads when changes are madegulp csscompiles SCSS files into CSS and minifies the compiled CSSgulp jsminifies the themes JS filegulp vendorcopies dependencies from node_modules to the vendor directoryYou must have npm installed globally in order to use this build environment. This theme was built using node v11.6.0 and the Gulp CLI v2.0.1. If Gulp is not running properly after runningnpm install, you may need to update node and/or the Gulp CLI locally.Bugs and IssuesHave a bug or an issue with this template?Open a new issuehere on GitHub or leave a comment on thetemplate overview page at Start Bootstrap.AboutStart Bootstrap is an open source library of free Bootstrap templates and themes. All of the free templates and themes on Start Bootstrap are released under the MIT license, which means you can use them for any purpose, even for commercial projects.https://startbootstrap.comhttps://twitter.com/SBootstrapStart Bootstrap was created by and is maintained byDavid Miller.https://davidmiller.iohttps://twitter.com/davidmillerherehttps://github.com/davidtmillerStart Bootstrap is based on theBootstrapframework created byMark OttoandJacob Thorton.Copyright and LicenseCopyright 2013-2020 Start Bootstrap LLC. Code released under theMITlicense.
Package: data-repos
DataRepos - A Namespace Package for Data FilesThis package provides a namespace intended for data files.It lets you read data files from a common package, but with the actual data distributed over multiple packages.For example, if you have various data files that are very large (on the order of hundreds of megabytes or larger), then you can divide the data files into different packages, but they'll be callable from the same namespace in your Python code.To use DataRepos, you should install it into your virtual environment:(venv)$python-mpipinstalldata-reposYou can now import DataRepos asdata_repos.Read Data FilesDataRepos provides aread()function that you can use to read data files. The data are returned as apandasDataFrame:>>>fromdata_reposimportread>>>read.data("countries")countrypopulation0Austria88405211Canada370577652Cuba113381383DominicanRepublic106271654Germany829057825Norway5311916...Install Data FilesYou can install other data files from PyPI with pip. Other cooperatingDataRepospackages can be installed and will integrate smoothly:(venv)$python-mpipinstalldata-repos-carsYou can then read the cars dataset with the exact same syntax:>>>fromdata_reposimportread>>>read.data("cars")...Because DataRepos is a namespace package, it can be extended on the fly.Available Data FilesTwo datasets are included as examples:iris: The classicalIris dataset, originallypublishedby Ronald Fisher in 1936countries: Countries and their population, collected bySamayoYou can read these files withread.data("iris")andread.data("countries"), respectively.Add Your Own Data FilesYou can also add your own data files by storing them in a folder nameddata_reposthat's on Python's path.See examples of how to do this and learn more about namespace packages inWhat's a Python Namespace Package, and What's It For?
Package: data-repos-cars
DataReposCars - A Cars Dataset for DataReposThis package provides an example cars-dataset forDataRepos.To use DataReposCars, you should install it into your virtual environment:(venv)$python-mpipinstalldata-repos-carsYou can then read the data as a regular DataRepos dataset:>>>fromdata_reposimportread>>>read.data("cars")...Learn more about DataRepos, DataReposCars, and namespace packages inWhat's a Python Namespace Package, and What's It For?
Package: datareservoirio
The Python API forDataReservoir.io-datareservoiriocomes with all
batteries included. It provides both convenient high-level and low-level
access.We built the Python experience with engineers and data scientists in mind.
Because we believe insight arise when engineers are empowered with the right
data at the right time, and in the right manner. In fact,datareservoiriois
best friends with the rich Python scientific
ecosystem! It works natively withPandasobjects, and thus a perfect match
if you work withNumpy,SciPy,Matplotlib,scikit-learn, and many
more!datareservoiriois also a comprehensive library that can be used to
build other apps and services. The path from experimentation to apps and
services got a little bit shorter!
Package: dataride
dataride: lightning-fast data platform setup toolkitIntroductiondatarideis a Python package that enables creating data platform infrastructure within seconds for small/medium projects as well as PoCs (Proof of Concept). It aims to generate ready-to-deploy code for various frameworks, including tools like Terraform and Apache Airflow. It makes use of YAML configuration files to read data platform features that the user is willing to set up.RequirementsThe underlying logic makes heavy use of Terraform and Jinja templating. Therefore, to fully exploit package features, it's recommended to install Terraform beforehand (possibly one of the latest stable versions). Instructions on how to do this can be found on theofficial Terraform tutorial website.ExampleBelow you can find and example of running thedatarideCLI, using config examples that were prepared inside theconfig_examples/directory. It takes20 secondsto go from ready config file to infrastructure setup generation.dataride create -c config_examples/scenario_aws_s3_and_data_catalog.yaml -d results/infra_s3_and_glueDocumentationFor further description of the package's features, please refer todocsdirectory. All the necessary information is stored there.CollaborationIf you see any room for improvement, feel free to submit a PR! Let's develop dataride to suit as many data teams as possible.
Package: datarize
repo-templateThis repository is a template for creating new repositories, mainly for python projects. There are a few configuration enforced to make sure dependencies are managed properly and commits follow a certain formats.ToolsSome of the tools that we uses includes:Dependencies and environment:PoetryPre-commit checks:Pre-commitPre-commit message checks:Conventional commitCustom code formatting in pre-commit:Code formatting:Flake8Imports sorting:iSortSetupThis are some of the steps to run to fully utilize what is configurated.Install PoetryRun the following command to install poetry
Linux, macOS, Windows (WSL):curl -sSL https://install.python-poetry.org | python3 -Windows (Powershell):(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -* refer to thepoetry official documentationif it is not working as intended.VSCodeThis part is only required if you plan to use Visual Studio Code and select the interpreted to test:poetry config virtualenvs.in-project trueIf you have already ranpoetry install, run the following code after the line above to recreate a new environment so that VSCode can detect it.poetry env list;  # shows the name of the current environment
poetry env remove <current environment>;
poetry install;  # will create a new environment using your updated configurationInstall dependenciesRun the following command to install pre-defined library required for this repo:poetry installDevelopingTesting on the environmentRun the following command to start an isolated sub-shell with the poetry environment:poetry shellAdding new package/libraryThe following command will add the specified package and resolve the dependencies if required:poetry add <package-name>
Package: datarobot
About datarobotDataRobot is a client library for working with theDataRobotplatform API.This package is released under the terms of the DataRobot Tool and Utility Agreement, which
can be found on ourLegalpage, along with our privacy policy and more.InstallationPython >= 3.7 are supported.
You must have a datarobot account.$ pip install datarobotUsageThe library will look for a config file~/.config/datarobot/drconfig.yamlby default.
This is an example of what that config file should look like.token: your_token
endpoint: https://app.datarobot.com/api/v2Alternatively a global client can be set in the code.import datarobot as dr
dr.Client(token='your_token', endpoint='https://app.datarobot.com/api/v2')Alternatively environment variables can be used.export DATAROBOT_API_TOKEN='your_token'
export DATAROBOT_ENDPOINT='https://app.datarobot.com/api/v2'Seedocumentationfor example usage after configuring.Helpful linksAPI quickstart guideCode examplesCommon use casesBug Reporting and Q&ACreate an account onDataRobot Communityand post your questions and bug reportshere.
Package: datarobot-bosun
Bosun - DataRobot's MLOps event managerThis is the Python Bosun package, which complements the Bosun distribution. In this package you will find two important components of the Bosun system:
- TheBosun Python plugin framework- TheBosun model connector frameworkInstallationThe Bosun wheel is provided as part of the MLOps Agents tarball. To install the Bosun Python module:pipinstalldatarobot-bosunAdditional Plugin DependenciesThe basic install will provide support for thefilesystemplugin; however, there are several other reference plugins that are provided with this package but which require additional dependencies that are not installed by default. For convenience, we provide the following optional dependencies that will install the packages necessary for the relevant plugin:docker- Installs dependencies for thedockerplugin.kubernetes- Installs dependencies for thekubernetesplugin.s3- Installs dependencies for thes3plugin. It also enables support for fetching external model artifacts from S3 (regardless of plugin used).You can install these extra dependencies usingpip, for example:pipinstalldatarobot-bosun[docker]You can also install multiple sets of dependencies at once, for example:pipinstalldatarobot-bosun[kubernetes,s3]The Bosun Python Plugin FrameworkThis framework provides a simple way to develop a Bosun plugin in Python. A Bosun Python plugin is a Python class that implements several API methods, one method for each Bosun action. The plugin framework provides a runner scrip that is used to run the plugin as an external program. This way the plugin writer does not need to worry about handling command line arguments.Exampleplugin-runner--plugintest--configmy_config.yaml--actionpe_status--status-file/tmp/status.jsonThe example above will invoke theplugin-runnerprogram which in turn will load and run the test plugin. Themy_config.yamlfile will be loaded and the configuration will be provided to the plugin. The action to run ispe_statuswhich is supposed to return the status of the prediction environment. The--status-fileargument is the path to the status file that should contain the plugin result of running the action.The Bosun Model Connector FrameworkThis framework provides a simple way to develop and test model connectors. A model connector is a program that fetches the model artifact given the model metadata. This framework provides some built-in support for models stored on S3 and local file systems.
Package: datarobot-bp-workshop
The Blueprint Workshop is built to ensure that constructing and modifying DataRobot blueprints
through a programmatic interface is idiomatic, convenient, and powerful.This library requires aDataRobotaccount.The easiest way to get started is by reading theDocumentation.This package is covered under the DataRobot Tool and Utility Agreement, which can be
read on ourLegalpage, along with our privacy policy and more.PrerequisitesPython >= 3.7Ensure your DataRobot account has enabled:Show Uncensored BlueprintsEnable Customizable BlueprintsInstallationOptionally, create a virtual environment$ mkvirtualenv -p python3.7 blueprint-workshopInstall Graphviz on Linux (to render blueprints):$ sudo apt-get install graphvizInstall Graphviz on Mac (to render blueprints):$ brew install graphvizInstall the library!$ pip install datarobot-bp-workshopRecommended:$ pip install jupyterlabFrom a folder where you’d like to save your scripts:$ jupyter-lab .
Package: datarobot-early-access
About datarobot_early_accessDataRobot is a client library for working with theDataRobotplatform API. This package is the “early access” version of the client.Do NOT use this package in production–you will expose yourself to risk of breaking changes and bugs.For the most stable version, see the quarterly release on PyPI athttps://pypi.org/project/datarobot/.This package is released under the terms of the DataRobot Tool and Utility Agreement, which
can be found on ourLegalpage, along with our privacy policy and more.InstallationPython >= 3.7 are supported.
You must have a datarobot account.$ pip install datarobot_early_accessUsageThe library will look for a config file~/.config/datarobot/drconfig.yamlby default.
This is an example of what that config file should look like.token: your_token
endpoint: https://app.datarobot.com/api/v2Alternatively a global client can be set in the code.import datarobot as dr
dr.Client(token='your_token', endpoint='https://app.datarobot.com/api/v2')Alternatively environment variables can be used.export DATAROBOT_API_TOKEN='your_token'
export DATAROBOT_ENDPOINT='https://app.datarobot.com/api/v2'Seedocumentationfor example usage after configuring.Helpful linksAPI quickstart guideCode examplesCommon use casesBug Reporting and Q&ACreate an account onDataRobot Communityand post your questions and bug reportshere.