Saravanan666/pypi-org huggingface dataset:
Package: odd-ge-adapter
ODD GreatExpectation adapterLibrary for GreatExpectation schema compatible json files for suites and validation, reads them from s3 storage and ingests to OpenDataDiscovery platform.Suites must include special metadata about folder with data which will be validated in the future.
Example{"expectation_suite_name":"notification",..."meta":{"batch_kwargs":{..."odd_metadata":["s3://bucket/folder"]}}}Validation results must include metadata about which file was validated.
Example{"meta":{"batch_kwargs":{..."odd_metadata":["s3://bucket/folder/file.csv"]},..."validation_time":"20220525T174015.717924Z"},"results":[...],"success":true}Library usageInstall packagepipinstallodd-ge-adapterExample:from odd_models.api_client import ODDApiClient
from odd_ge_adapter.domain.plugin import S3StoragePlugin
from odd_ge_adapter.adapters.s3.adapter import Adapter

platform = ODDApiClient(<PLATFORM_URL>)

# aws credentials can be omitted and taken from the ENV variables 
config = S3StoragePlugin(
    type="s3",
    name="s3_storage",
    bucket="",
    results_key="",
    suites_key="",
    # aws_account_id="",
    # aws_region="",
    # aws_access_key_id="",
    # aws_secret_access_key="",
    # aws_session_token=""
)

adapter = Adapter(config)
platform.post_data_entity_list(data=adapter.get_data_entity_list())As collector usageIn progress...
Package: odd-great-expectations
OpenDataDiscovery Action for handling Great Expectations tests results.What is it?odd_great_expectation.action.ODDActionIs a class derived from GXValidationActionwhich will be run by GreatExpectations at runtime withValidationResults for checkpoint.How to use it?:Installodd-great-expectationspackagepipinstallodd-great-expectationsAddODDActionaction to some checkpoint's action list:name:<CHECKPOINT_NAME>config_version:1.0...action_list:# other actions-name:store_metadata_to_oddaction:module_name:odd_great_expectations.actionclass_name:ODDActionplatform_host:<PLATFORM_HOST>data_source_name:<DATA_SOURCE_NAME>Parameters:platform_host- Location of OpenDataDiscovery platform, i.e.http://localhost:8080platform_token- OpenDataDiscovery token, how to get it -https://docs.opendatadiscovery.org/configuration-and-deployment/trylocally#create-collector-entitydata_source_name- Unique name for data source, i.e. local_qa_testBothplatform_hostandplatform_tokencan be set usingODD_PLATFORM_HOSTandODD_PLATFORM_PLATFORMenv variables accordingly.Run checkpointgreat_expectationscheckpointrun<CHECKPOINT_NAME>Check results onPLATFORM_HOSTUI.Supporting featuresFeatureSupportingV3 API ++SqlAlchemyEngine+PandasEngine+Great Expectations V2 API --Cloud Solution-
Package: oddity
# Oddity: Time Series Anomaly DetectionOddity is a time series anomaly detection tool for Python, implemented in Rust. Oddity is capable of learning trend, global seasonality and even local seasonality from time series data, and works best in these situations.Being written in Rust, Oddity is incredibly fast and can generally fit to even a few thousand time steps in minimal time.Oddity also provides a few other tools along with anomaly detection, such as:STL decompositiongaussian process fittinggaussian distribution fittingPeriodicity inferenceMore functionality along with general optimizations will be added in the future.
Package: oddl
oddl (OpeNDAP Downloader)oddl (OpeNDAP Downloader): a GUI-based Python app for downloading and saving netCDF data via OpeNDAP.Note: This is an experimental project.Installation:pip install oddlThe app can be run from the command line via:oddlOr you can run it via script via:from oddl import run

run()DocumentationUsage documentation is available inPDF form.AuthorsChris DrozdowskiLicenseThis project is licensed under the MIT License.
Package: odd-ml
odd-mlWork withOpen Data Discoveryinside your notebook.ExampleNotebook exampleWhat you can do using odd-ml:Get list of entities from ODD PlatformGet detailed information about entityLoad dataframe, if dataset stored on S3Get dataframe's profileDisplay embedded pages from ODD Platform UI:DetailedEntity structure (useful for datasets)LineageSearch resultRoadmapAdd more filters for fetching data entities (i.e by namespace)Add more dataset's storages
Package: odd-models
OpenDataDiscovery Models packageHas some useful tools for working with OpenDataDiscovery. Such as:Generated Python models from OpenDataDiscovery specification.API Client for working with OpenDataDiscovery.API for manual discovering data entities.Installationpipinstallodd-modelsModels using exampleodd-models.modelspackage provides automatically generated Python model by OpenDataDiscovery specification.
It can be used for creating data entities for uploading them into the Platform.Code example (full code):fromoddrn_generatorimportPostgresqlGeneratorfromodd_models.modelsimportDataEntity,DataSet,DataSetField,DataSetFieldType,DataEntityType,Type,MetadataExtensiongenerator=PostgresqlGenerator(host_settings="localhost",databases="my_database",schemas="public")DataEntity(oddrn=generator.get_oddrn_by_path("tables","my_table"),name="my_table",type=DataEntityType.TABLE,metadata=[MetadataExtension(schema_url="https://example.com/schema.json",metadata={"env":"DEV"})],dataset=DataSet(field_list=[DataSetField(oddrn=generator.get_oddrn_by_path("tables_columns","name"),name="name",type=DataSetFieldType(type=Type.TYPE_STRING,logical_type='str',is_nullable=False),)]))HTTP Client for OpenDataDiscoveryodd-models.clientpackage provides API client for OpenDataDiscovery API.
Client provides an API for working with OpenDataDiscovery Platform.
It has various methods for working with data sources, data entities, management etc.Code example(full code):fromexamples.postgres_modelsimportdata_entity_list,generatorfromodd_models.api_client.v2.odd_api_clientimportClientclient=Client(host="http://localhost:8080")client.auth(name="postgres",description="Token for dev AWS account data sources")client.create_data_source(data_source_oddrn=generator.get_data_source_oddrn(),data_source_name="Postgres data source",)client.ingest_data_entity_list(data_entities=data_entity_list)Manual Discovery APIWhen there is no programmatic way to discover data sources and data entities,odd-models.discoverypackage provides API for manual discovery of data sources and data entities.Code example(full code):fromodd_models.discoveryimportDataSourcefromodd_models.discovery.data_assetsimportAWSLambda,S3Artifactfromodd_models.discovery.data_assets.data_asset_listimportDataAssetsListwithDataSource("//cloud/aws/dev")asdata_source:validation_lambda=AWSLambda.from_params(region="eu-central-1",account="0123456789",function_name="validation")input_artifact=S3Artifact.from_url("s3://bucket/folder/test_data.csv")results=S3Artifact.from_url("s3://bucket/folder/test_result.csv")metrics=S3Artifact.from_url("s3://bucket/folder/test_metrics.json")input_artifact>>validation_lambda>>DataAssetsList([results,metrics])data_source.add_data_asset(validation_lambda)DevelopmentInstallation# Install dependenciespoetryinstall# Activate virtual environmentpoetryshellGenerating models# Generate models. Will generate models pydantic into odd_models/modelsmakegenerate_models# Generate api client. Will generate api client into odd_models/api_clientmakegenerate_clientTestspytest.Docker builddockerbuild-todd-models.
Package: odds
Outlier Data Detection Systems - ODDSAs used in paper "Simple Models are Effective in Anomaly Detection in Multi-variate Time Series"This work was funded by the grant "Early detection of contact distress for enhanced performance monitoring and predictive inspection of machines" (EP/S005463/1) from the Engineering and Physical Sciences Research Council (EPSRC), UK.pip install oddsThe work is done by theODobject. Import the 'OD' object as follows:from odds import ODInstantiate the object with the 'algo' argument, where a short string represents the algorithm you wish to use. In this case, 'VAR' refers to vector autoregression, a simple linear multidimensional regression algorithm. Other implemented algorithms are listed below.od = OD('VAR')To use the object, you need to call the 'get_os()' function, with 'X' as its argument, where X is a data matrix,nsamples bypfeatures.p must be 2 or greater to workon many of the systems, this returns a vector with n scores, one for each sample.outlier_scores = od.get_os(X)The higher scores are the more outlying. you can then set a threshold if you wish, or just look at the ranking. Scores have not been sanitised, they may contain 'nan' values particularly from the 'VAE' if the data input has not been scaled. However it seems other algorithms work better without scaling, so inputs are not automatically scaled.Hyperparameters for each of these algorithms are currently fixed to the values in my paper, however at some point I will be finishing implementing a pass though allowing you to specify the hyperparameters at instantiation. This is on my ToDo list.To get normalised (between 0 and 1) scores, use the 'norm' keyword argument. This may result in errors if the data is not normalised, as there may be infinite values in the scores (usually only from the 'VAE').normalised_scores = od.get_os(X, norm=True)Valid strings for outlier algorithms:'VAR' Vector Autoregression'FRO' Ordinary Feature Regression'FRL' LASSO Feature Regression'FRR' Ridge Feature Regression'GMM' Gaussian Mixture model'IF' Isolation Forest'DBSCAN' Density Based Spatial Clustering and Noise'OCSVM' One Class Support Vector Machine'LSTM' Long Short Term Memory'GRU' Gated Recurrent Unit'AE' Autoencoder'VAE' Variational Autoencoder'OP' Outlier Pursuit'GOP' Graph Regularised Outlier Pursuit'RAND' Random scoring (for baseline comparison)Hyperparameter table
Package: oddsapi
The Odds-ApiInstallationThe package requires Python 3.7 or higher.
Install latest version from PyPI:pip install oddsapiDescriptionThe Odds-API provides sports odds data for loads of sports from bookmakers around the world. Get your free API keyhere.UsagePlease refer todocumentationfor detailed instructions for The Odds-Api.To start using the wrapper import and initialize theOddsApiClientfrom the package.fromoddsapiimportOddsApiClientclient=OddsApiClient(api_key='YOUR KEY')response=client.retrieve_sports()The response is a custom object that stores the data in nested namespaces and dictionary format.response.data[0]>>>Collection(active=True,details='US College Football',group='American Football',has_outrights=False,key='americanfootball_ncaaf',title='NCAAF')#alternativelyresponse.json['data'][0]>>>{'key':'americanfootball_ncaaf','active':True,'group':'American Football','details':'US College Football','title':'NCAAF','has_outrights':False}response.rate_info>>>{'requests_remaining':'479','requests_used':'21'}The client can also be configured to work withasyncio.fromasyncioimportgatherclient.aio=Truecors=[client.retrieve_odds(sport_key=sport.key,region='us',mkt='spreads')forsportinresponse.data[:4]]responses=client.loop.run_until_complete(gather(*cors))Keep in mind thatrate_infowill not be recorded in order.ContactEmail me atsarartur.ruk@gmail.comor open a newIssueon Github.
Package: oddsgym
Sports odds betting environmentA sports betting environment for OpenAI Gym.Installationpip install oddsgymEnvironmentThe starting bank is X (X > 0), representing X available bets.
Actions are all available bets for a game (depends on sport), placing 1 bet for each option. Also, the agent can not bet over his current bank (i.e can't place 3 bets when the current bank is 2).
For example, in 3-way betting for soccer, the avilable actions are:1. Bet on home team
2. Bet on away team
3. Bet on draw
4. Bet on home team and away team
5. Bet on home team and draw
6. Bet on away team and draw
7. Bet on home team and away team and draw
8. Don't place a bet for this gameA step is placing a bet on a single game. In each step, the agent knows the betting odds for this game.
The reward for each step is the amount of money won (negative reward when losing money).
An episode is betting for a whole year or when "striking out" (losing all the money).DocumentationThe full documentation is hosted at:https://oryjonay.github.io/Odds-Gym
Package: oddsmaker
oddsmakerPackage that implements common ratings systems that are applicable to a wide range of sports and data types.OverviewThe problem that this package sets out to address is that a lot of publicly available time series prediction methods are inadequate for predicting sports because of the pairwise nature of many sporting competitions. In other words, something like an ARIMA model would have some predictive power, however it is not by default capable of taking into account opponent quality. This package implements and extends many public rating systems that both adjust for opponent and (mostly) have time components as well.The goal of this package is to be able to quickly test and apply many of these rating options to data of a generic structure. For more explanation, check out the Quick Start and Documentation.Implemented Algorithms (v 0.1.0)State SpaceClassic EloElo with UncertaintyLinearRidgeKenPomMasseyGraphPagerankMany more (hopefully) coming!InstallationQuick StartDocumentation and Other Links
Package: oddsman
# OddsWacther## Environment
Python 3.5.1## Usage### install
enter below commands`sudo pip installgit+https://github.com/PinkPhayate/OddsWatcher`### how to use` from oddsman import oddsman ods = oddsman.OddsWatcher() `## Document of API
### get_race_ids(time: str)paramatertime: str       日付featureパラメータで入力した日付のレースを確認し、あれば出走時刻をkeyとしたdicttionaryを返すexample` from oddsman import OddsWatcher odds_man = OddsWatcher() todays_race_id =odds_man.get_race_ids('0625')# => {'10:45': '201702010403', '10:55': '201705030803', '16:15': '201705030812', '12:35': '201702010406', '12:55': '201709030806', '12:45': '201705030806', '11:05': '201709030803', '10:05': '201709030801', '15:30': '201705030811', '13:35': '201702010408', '12:25': '201709030805', '13:15': '201705030807', '09:55': '201705030801', '10:15': '201702010402', '14:15': '201705030809', '14:50': '201705030810', '10:35': '201709030802', '14:05': '201702010409', '15:40': '201709030811', '16:30': '201709030812', '10:25': '201705030802', '12:15': '201705030805', '12:05': '201702010405', '16:05': '201702010412', '11:35': '201709030804', '14:40': '201702010410', '15:01': '201709030810', '15:20': '201702010411', '13:25': '201709030807', '13:45': '201705030808', '09:50': '201702010401', '13:05': '201702010407', '14:25': '201709030809', '11:15': '201702010404', '13:55': '201709030808', '11:25': '201705030804'} `### get_race_odds(race_id: str)paramaterrace_id: str   レースidfeatureオッズを調べたいレースのidを入力すると、オッズが返ってくるexample` from oddsman import OddsWatcher odds_man = OddsWatcher() race_id = '201702010412' odds_dict = odds_man.get_race_odds(race_id) # => {津軽海峡特別: ['61.0', '93.9', '33.4', '69.3', '1.6', '7.9', '44.9', '11.3', '3.5','22.1']}`
Package: oddsnends
Miscellaneous data science methodsFree software: MIT licenseDocumentation:https://oddsnends.readthedocs.io.FeaturesClassesAttrDictTypesIntervalTypeLoggingLevelsNoneTypeNumericSeriesTypeTwoTupleIntsMethodsGeneraldefaultdefaultsis_nullmsgnowparse_literal_evalFor collectionsaggdict2listdrop_duplicatesdropnapopssimplifystrictcollectionFor intervalscalc_intervalsintervals2locssetops_rangesMathroundingceilingfloorpandas toolsassigncheck_if_existsdedup_aliaspipe_concatget_level_uniquespivot_indexed_tablereorder_colssort_levelsswap_index
Package: ode
odeThis module provides numeric integrators for ordinary differential equations
with usage similar to matlab integrators such as ode45.Free software: MIT licenseDocumentation:http://ode-solver.readthedocs.io/.Integration methods:Euler’s methodBackward Euler methodVerlet method:For each integrator a generator and a standard version is included.History0.4.0 (2019-07-21)Now requires numpyReplaces list comprehension addition/multiplication with array mathupdate docs/double-pendulum-example to use an array dot-function and
place it on the usage–>examples page of the documentation.The date on 0.3.0 was wrong – should have been 2019-07-200.3.0 (2019-06-10)BREAKS COMPATIBILITYOutput changes from [t, [[x0, v0], [x1, v1] …]]
to [t, [[x0, x1, …], [v0, v1, …]]].0.2.0 (2018-06-10)Refactor to improve readability and code reuse.Clean tempating and testingUpdate documentation0.1.2 (2018-03-06)Add verlet integration0.1.1 (2018-03-05)Add generator versions of Euler and backward Euler methods.0.1.0 (2018-03-03)First release on PyPI.
Package: odeanimate
ODE AnimateThis project aims to be a set of tools for solving, plotting, and animating curves and fields.The rational for this is,trying to use pure-pythonto do numerical analysis.Most techniques here are going to be without the use of any external modules.The only external modules that are useddirectlyby this project are:matplotlib, which is used to configure thefiguresfor plotting.FeaturesMost of this features areW.I.P.(work in progress)Vector objects withbasicoperations.Vector objects withbasicoperations.Function utilities forreal valuedfunctions.Automatic plotting forreal valuedfunctions.GenericODEintegrators.Utilities for curves.Utilities for surfaces.Animation Loop and widgetsDevelopmentThis project usespipenvfor local development and testing.If you are intending to:Add examples or documentation,develop further this moduleuse and test in an isolated enviromentyou should havepipenvinstalled.One you cloned the repository, you should be able to executepipenv install --devand everything should be working.Most of what you would need is configured in thepyproject.tomlfile, so if you are using the tools specified in
thescriptssection of thePipfileyou should be fine.ContributeIf you wish to contribute you can contact me directly, or open an issue in the github repository.
The main development for this module is done in a private repository, but for visibility and public
interaction I'll host this in github too.LicenseThis project is under theGPL2 License.
Package: odecloud
Official OdeServer Python API's ClientGetting Started & UsageInstallation:Use Poetry:$poetryaddodecloudOr, use Pip:$pipinstallodecloudInstantiate your connection to OdeCloud's API:If you don't know your client credentials:api=Api('https://server.odecloud.app/api/v1')# All API calls will be made to this domain.api.login('your-email@here.com','your_password')If you already know your client credentials:api=Api(base_url='https://server.odecloud.app/api/v1',# All API calls will be made to this domainclient_key='YOUR CLIENT KEY',client_secret='YOUR CLIENT SECRET',)Now, any calls can be made to OdeCloud's API. Examples below:api.comments.get(createdBy=random_user_id)# GET /api/v1/comments?createdBy=random_user_id/api.comments.post(data=expected_payload)# POST /api/v1/comments/api.comments(random_comment_id).patch(data=expected_payload)# PATCH /api/v1/comments/random_comment_id/api.comments(random_comment_id).delete()# DELETE /api/v1/comments/random_comment_id/Happy coding!Publishing to PyPIOn the root of the directory, open uppyproject.tomlBump theversionby the following guideline:Our version numbering followsMajor.Minor.Patch(e.g. 2.10.1)Major: Stable release.Minor: Incremental changes--including new API, remove API, or change of behavior of the API.Patch: Small efficient changes--including a fixed to a bug.Note: in regards to Patch if the old functionality was always erroneous, then it will be considered a Patch.Publish a new tag on the repository by going tohttps://gitlab.com/odetech/python_odecloud/-/tags/new.Note: make sure that the "Tag Name" is an exact match to the version insidepyproject.tomlon step #2.In regards to the "Release notes": we encourage detail and consistent format in order for other developers to understand the new version update.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: odeintw
odeintwprovides a wrapper ofscipy.integrate.odeintthat allows it to
handle complex and matrix differential equations.  That is, it can solve
equations of the formdZ/dt = F(Z, t, param1, param2, …)wheretis real andZis a real or complex array.Sinceodeintwis just a wrapper ofscipy.integrate.odeint, it requiresscipyto be installed.  SciPy 0.15 or greater is required, to avoid a
bug inscipy.stats.odeintin older versions of SciPy.See README.md athttps://github.com/WarrenWeckesser/odeintwfor examples.
Package: odenlls
odenllsis a Python3 library for simulating and fitting chemical
kinetics data. These two pieces are accomplished as follows:Kinetic models are simulated using numerical simulations of the
ordinary differential equations (ODE) for an arbitrary set of
chemical reactions. Rate constants and starting concentrations can be
varied arbitrarily to observe the predicted changes in concentration
with time.These ODE simulations are fit to experimental kinetic data using
non-linear least squares (nlls) methods. These fits yield the
best-fit rate constant and concentration parameters for a given set
of kinetic data.DependenciesThis package consists of a single Python module file that was developed
using Python 3.6; however, it should work on most other Python 3
versions with the appropriate external dependencies listed below.Numpy >= 1.13.3scipy>=1.0.0pandas>=0.21.1matplotlib>=2.1.1The package versions above were used during development. Older/newer
versions should work as well. Older versions of these modules may work
as well, but you may want to run thepy.testunit tests (coming
soon) to ensure they work properly.Installationodenllsis installable using either Python’spippackage manager
orconda, the package manager for theAnaconda Python distribution.To get the latest release usingpip, use the following command:$ pip install odenllsOr to install from the latest GitHub commit:$ pip install git+https://github.com/rnelsonchem/odenlls.gitUsingconda, the following command will install the latest release
of this package.$ conda install -c rnelsonchem odenllsUsageTheodenllsmodule capabilities are demonstrated in severalJupyternotebooks, which are located in the
“examples” directory on theGitHub project
page. A summary of these
notebooks is as follows:TheTLDR
Notebookis a very brief overview ofodenllsfunctionality with very little
explanatory text.Notebook
1demonstrates simulation of a simple first-order irreversible
reaction.InNotebook
2,
reaction data fitting is shown for a user-generated set of
first-order irreversible reaction data.Notebook
3highlights fitting of a real-world data set using a series of
reversible first-order reactions.
Package: odeo-python-sdk
Odeo Python SDKPython library for calling Odeo For Business API, such asDisbursement,Payment Gateway,Cash, andSub Usersservices.InstallationThe SDK currently supports Python 3.9 and later.To use Odeo Python SDK, install the latest version withpip:pipinstallodeo-python-sdkDocumentationFor more detailed guides of how to use and set up the SDK please go tohttps://odeo-python-sdk.readthedocs.io