Saravanan666/pypi-org huggingface dataset:
Package: oceansdb
Package to subsample, or interpolate, climatologies like WOA to any coordinates.This package started with functions to obtain climatological values to compare with measured data, allowing a quality control check by comparison. It hence needed to work for any coordinates requested. I split these functionalities fromCoTeDeinto this standalone package to allow more people to use it for other purposes.Free software: 3-clause BSD style license - see LICENSE.rstDocumentation:https://oceansdb.readthedocs.io.FeaturesIf the database files are not localy available, automatically download it.Extract, or interpolate if necessary, climatologic data on requested coordinates;Can request a single point, a profile or a section;Ready to handle -180 to 180 or 0 to 360 coordinate system;Ready to use with:World Ocean Atlas (WOA)CSIRO Atlas Regional Seas (CARS)ETOPO (topography)Quick howto useInside python:>>>importoceansdb>>>withoceansdb.WOA()asdb:Find out what is available:>>>db.keys()Average temperature at one point:>>>t=db['sea_water_temperature'].extract(var='mean',doy=136.875,depth=0,lat=17.5,lon=-37.5)A profile of salinity:>>>t=db['sea_water_salinity'].extract(var='mean',doy=136.875,depth=[0,10,15,18],lat=17.5,lon=-37.5)A full depth section of temperature:>>>t=db['sea_water_temperature'].extract(var='mean',doy=136.875,lat=17.48,lon=[-39,-37.5,-35.2])Using CARS instead of WOA:>>>withoceansdb.CARS()asdb:>>>t=db['sea_water_temperature'].extract(var='mean',doy=136.875,lat=17.48,lon=[-39,-37.5,-35.2],depth=[0,10,120,280])Or to get topography for one point from the 1 min arc resolution:>>>withoceansdb.ETOPO(resolution='1min')asdb:>>>h=db['topography'].extract(lat=17.5,lon=0)
Package: oceansoundscape
AboutA python package for analyzing ocean acoustic data.Author: Danelle Cline,dcline@mbari.orgPrerequisitesPython 3.8 or 3.9Installationpip install oceansoundscapeDocumentationFull documentation is available athttps://docs.mbari.org/oceansoundscape/DevelopmentThis project is developed usingpoetry.  To install poetry, follow the instructionshere.  Once poetry is installed, you can install the project dependencies by running:poetry installTo run the tests, run:poetry run pytestSee the DEV.md for more information on development.
Package: ocean-spark-airflow-provider
Airflow connector to Ocean for Apache SparkAn Airflow plugin and provider to launch and monitor Spark
applications onOcean for
Apache Spark.Installationpip install ocean-spark-airflow-providerUsageFor general usage of Ocean for Apache Spark, refer to theofficial
documentation.Setting up the connectionIn the connection menu, register a new connection of typeOcean for
Apache Spark. The default connection name isocean_spark_default. You will
need to have:The Ocean Spark cluster ID of the cluster you just created (of the
formatosc-e4089a00). You can find it in the Spot console in thelist of
clusters,
or by using theCluster
ListAPI.A Spot
tokento interact with the Spot API.TheOcean for Apache Sparkconnection type is not available for Airflow
1, instead create anHTTPconnection and fill your cluster id ashost, and your API token aspassword.You will need to create a separate connection for each Ocean Spark
cluster that you want to use with Airflow.  In theOceanSparkOperator, you can select which Ocean Spark connection to
use with theconnection_nameargument (defaults toocean_spark_default). For example, you may choose to have one
Ocean Spark cluster per environment (dev, staging, prod), and you
can easily target an environment by picking the correct Airflow connection.Using the Spark operatorfromocean_spark.operatorsimportOceanSparkOperator# DAG creationspark_pi_task=OceanSparkOperator(job_id="spark-pi",task_id="compute-pi",dag=dag,config_overrides={"type":"Scala","sparkVersion":"3.2.0","image":"gcr.io/datamechanics/spark:platform-3.2-latest","imagePullPolicy":"IfNotPresent","mainClass":"org.apache.spark.examples.SparkPi","mainApplicationFile":"local:///opt/spark/examples/jars/examples.jar","arguments":["10000"],"driver":{"cores":1,"spot":false},"executor":{"cores":4,"instances":1,"spot":true,"instanceSelector":"r5"},},)Using the Spark Connect operator (available since airflow 2.6.2)fromairflowimportDAG,utilsfromocean_spark.operatorsimport(OceanSparkConnectOperator,)args={"owner":"airflow","depends_on_past":False,"start_date":utils.dates.days_ago(0,second=1),}dag=DAG(dag_id="spark-connect-task",default_args=args,schedule_interval=None)spark_pi_task=OceanSparkConnectOperator(task_id="spark-connect",dag=dag,)Trigger the DAG with config, such as{"sql":"select random()"}more examples are available forAirflow 2.Test locallyYou can test the plugin locally using the docker compose setup in this
repository. Runmake serve_airflowat the root of the repository to
launch an instance of Airflow 2 with the provider already installed.
Package: ocean-spark-connect
Wrapper to create Spark Connect session for Spark Applications in Oceanfrom ocean_spark_connect.ocean_spark_session import OceanSparkSession

spark = OceanSparkSession.Builder().cluster_id("osc-cluster").appid("appid").profile("default").getOrCreate()
spark.sql("select random()").show()
spark.stop()Options for OceanSparkSession.Builder with and without default valuesIn addition to the existing SparkSession.Builder option, the following options are available:tokenprofileappidaccount_idcluster_idhost = "api.spotinst.io"port = "15002"bind_address = "0.0.0.0"
Package: oceanspy
Interactive DemoCheck out the interactive demonstration of OceanSpy atwww.bndr.it/gfvgdFor publications, please cite the following paper:Almansi, M., R. Gelderloos, T. W. N. Haine, A. Saberi, and A. H. Siddiqui (2019). OceanSpy: A Python package to facilitate ocean model data analysis and visualization.Journal of Open Source Software, 4(39), 1506, doi:https://doi.org/10.21105/joss.01506.This material is based upon work supported by the National Science Foundation under Grant Numbers 1835640, 124330, 118123, and 1756863. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of the National Science Foundation.What is OceanSpy?OceanSpyis an open-source and user-friendly Python package that enables scientists and interested amateurs to analyze and visualize ocean model datasets.
OceanSpy builds on software packages developed by thePangeocommunity, in particularxarray,dask, andxgcm.
The integration of dask facilitates scalability, which is important for the petabyte-scale simulations that are becoming available.Why OceanSpy?Simulations of ocean currents using numerical circulation models are becoming increasingly realistic.
At the same time, these models generate increasingly large volumes of model output data, making the analysis of model data harder.
Using OceanSpy, model data can be easily analyzed in the way observational oceanographers analyze field measurements.How to use OceanSpy?OceanSpy can be used as a standalone package for analysis of local circulation model output, or it can be run on a remote data-analysis cluster, such as the Johns Hopkins UniversitySciServersystem, which hosts several simulations and is publicly available (seeSciServer Access, andDatasets).NoteOceanSpy has been developed and tested using MITgcm output. However, it is designed to work with any (structured grid) ocean general circulation model. OceanSpy’s architecture allows to easily implement model-specific features, such as different grids, numerical schemes for vector calculus, budget closures, and equations of state. We actively seek input and contributions from users of other ocean models (feedback submission).
Package: oceanumlab
oceanumlabA Jupyterlab extension to interact with the Oceanum.io platformThis extension is composed of a Python package namedoceanumlabfor the server extension and a NPM package namedoceanumlabfor the frontend extension.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstalloceanumlabUninstallTo remove the extension, execute:pipuninstalloceanumlabTroubleshootIf you are seeing the frontend extension, but it is not working, check
that the server extension is enabled:jupyterserverextensionlistIf the server extension is installed and enabled, but you are not seeing
the frontend extension, check the frontend extension is installed:jupyterlabextensionlistContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the oceanumlab directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Server extension must be manually installed in develop modejupyterserverextensionenableoceanumlab# Rebuild extension Typescript source after making changesjlpmbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstall# Server extension must be manually disabled in develop modejupyterserverextensiondisableoceanumlab
pipuninstalloceanumlabIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink namedoceanumlabwithin that folder.Testing the extensionServer testsThis extension is usingPytestfor Python code testing.Install test dependencies (needed only once):pipinstall-e".[test]"To execute them, run:pytest-vv-rap--covoceanumlabFrontend testsThis extension is usingJestfor JavaScript code testing.To execute them, execute:jlpm
jlpmtestIntegration testsThis extension usesPlaywrightfor the integration tests (aka user level tests).
More precisely, the JupyterLab helperGalatais used to handle testing the extension in JupyterLab.More information are provided within theui-testsREADME.Packaging the extensionSeeRELEASE
Package: ocean-utils
ocean-utilsProvides common functions to interact with the ocean system.Main componentsDID and DDODID format: 'did:op:<32bytes-hex-representation>DID is the universal identifier for assets in the Ocean networkDDO is the json document thatDID resolverGiven a valid did, returns the associated DDO document which define
the asset metadata and other services offered for the assetAquariusService Agreements
Package: oceanwaves
This toolbox provides a generic data storage object for ocean waves
data (OceanWaves). OceanWaves is built upon thexarray.Datasetdata storage object, but defines special variables for time, location,
frequency and direction. Many of its functionalities are obtained from
thepyswantoolbox,
originally developed by Gerben de Boer, and theswantoolstoolbox, originally
developed by Caio Eadi Stringari.The OceanWaves object supports various standard conversions, like:From significant wave height to spectralFrom omnidirectional to directionalFrom directional to omnidirectionalFrom spectral to significant wave heightFrom spectral to spectral wave periodFrom spectral to peak wave periodFrom directional to peak wave directionFrom degrees to radiansAutomated unit conversionThe OceanWaves object supports various standard plotting methods, like:Polar subplots for directional data on multiple locations/timesPolar subplots on a mapPlots supported byxarray.DatasetandSeabornThe OceanWaves object can be instantiated from:Raw dataSWaN 1D/2D spectral or table filesAnxarray.DatasetobjectAnother OceanWaves objectThe OceanWaves object can be written to:SWaN 1D/2D spectral filesOutput supported byxarray.Dataset(e.g. netcdf)Usage examples can be found in the IPython notebooknotebooks/oceanwaves.ipynb.Source code documentation is hosted athttp://oceanwaves.readthedocs.io/
Package: ocean-web3
ocean-web3💧 Python wrapper, allowing to integrate the basic Ocean/web3.py capabilitiesoceanprotocol.comTable of ContentsFeaturesPrerequisitesQuick-startCode styleTestingNew VersionLicenseFeaturesOcean-web3 include the methods to make easy the connection with contracts deployed in different networks.
This repository include also the methods to encrypt and decrypt information.PrerequisitesYou should have running a instance of BigchainDB and ganache-cli.
You can start running the docker-compose in the docker directory:Quick-startWhen you want to interact with the contracts you have to instantiate this class:fromocean_web3.ocean_contractsimportOceanContractsWrapperocean=OceanContractsWrapper(host='http://localhost',port=8545,config_path='config.ini')ocean.init_contracts()If you do not pass the config_path the wrapper will use the default values.
After that you have to init the contracts. And you can start to use the methods in the different contracts.You will find as well two methods that allow you to register and consume an asset.fromocean_web3.consumerimportregister,consumeregister(publisher_account=ocean.web3.eth.accounts[1],provider_account=ocean.web3.eth.accounts[0],price=10,ocean_contracts_wrapper=ocean,json_metadata=json_consume)consume(resource=resouce_id,consumer_account=ocean.web3.eth.accounts[1],provider_account=ocean.web3.eth.accounts[0],ocean_contracts_wrapper=ocean,json_metadata=json_request_consume)Code styleThe information about code style in python is documented in this two linkspython-developer-guideandpython-style-guide.TestingAutomatic tests are setup via Travis, executingtox.
Our test use pytest framework.New VersionThebumpversion.shscript helps to bump the project version. You can execute the script using as first argument {major|minor|patch} to bump accordingly the version.LicenseCopyright 2018 Ocean Protocol Foundation Ltd.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: ocean-x-package-sdk
Getting Started with OceanX Bridge Platform APIsIntroductionOceanX Bridge Platform APIsInstall the PackageThe package is compatible with Python versions3 >=3.7, <= 3.11.
Install the package from PyPi using the following pip command:pipinstallocean-x-package-sdk==1.3.0You can also view the package at:https://pypi.python.org/pypi/ocean-x-package-sdk/1.3.0Initialize the API ClientNote:Documentation for the client can be foundhere.The following parameters are configurable for the API Client:ParameterTypeDescriptionbrand_idstringThis key is the brand's abbreviation. (example - "TS")Default:'TS'environmentEnvironmentThe API environment.Default:Environment.STAGINGhttp_client_instanceHttpClientThe Http Client passed from the sdk user for making requestsoverride_http_client_configurationboolThe value which determines to override properties of the passed Http Client from the sdk userhttp_call_backHttpCallBackThe callback value that is invoked before and after an HTTP call is made to an endpointtimeoutfloatThe value to use for connection timeout.Default: 60max_retriesintThe number of times to retry an endpoint call if it fails.Default: 0backoff_factorfloatA backoff factor to apply between attempts after the second try.Default: 2retry_statusesArray of intThe http statuses on which retry is to be done.Default: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524]retry_methodsArray of stringThe http methods on which retry is to be done.Default: ['GET', 'PUT']access_tokenstringThe OAuth 2.0 Access Token to use for API requests.The API client can be initialized as follows:fromoceanxbridgeplatformapis.oceanxbridgeplatformapis_clientimportOceanxbridgeplatformapisClientfromoceanxbridgeplatformapis.configurationimportEnvironmentclient=OceanxbridgeplatformapisClient(brand_id='TS',access_token='AccessToken')EnvironmentsThe SDK can be configured to use a different environment for making API calls. Available environments are:FieldsNameDescriptionTestingTesting environment used for internal testing.StagingDefaultStaging environment used for internal and external testing.ProductionProduction environment used for customer transactions only.AuthorizationThis API usesOAuth 2 Bearer token.List of APIsShipmentsInventoryProductsWebhooksClasses DocumentationUtility ClassesHttpResponseHttpRequest
Package: ocellaris
Ocellaris is a mass-conserving DG FEM solver for sharp-interface multiphase
free-surface flows. Ocellaris can simulate water entry and exit of objects in
ocean waves with accurate capturing of the force on the object and the
behaviour of the free surface. Some examples of what Ocellaris can do,
including videos of the results, are shown in theOcellaris Blogonwww.ocellaris.org.Ocellaris is implemented in Python and C++ withFEniCSas the backend for the
mesh and finite element assembly.PETScis used for solving the resulting
linear systems.Quick startInstallation and runningFirst stepsDocumentationDevelopmentCopyright and licenseOcellaris is named after theAmphiprion Ocellarisclownfish and is written as part of a PhD project at the University of Oslo.Installation and runningOcellaris requires a full installation ofFEniCSwith the PETSc linear algebra
backend. You can install the dependencies yourself (you need at least dolfin,
h5py, matplotlib and PyYAML), but the easiest way by far is to use a
preconfigured Singularity or Docker container. More information on these and
installation in general can be found in theuser guide.When Ocellaris is installed you can run the solver with an Ocellaris input
file:ocellaris INPUTFILE.INPExample input files can be found in thedemos/sub-directory of the
Ocellaris source code and a description of the Ocellaris input file format and
the possible input parameters is given in theuser guide.First stepsTo test the code there are some demo input files in thedemos/directory.
Complete input files along with driver scripts are provided for several of the
standard benchmark cases like Kovasznay flow and the Taylor-Green vortex in thecases/directory. More information can be found in the documentation which
also contains a description of the input file format.Please feel free to test Ocellaris, but please keep in mind:Ocellaris is in a state of constant developmentOcellaris is tested with FEniCS Version 2018.1. Earlier versions will NOT
work, later version may possibly work.This is an ongoing research project, do not expect results to be correct
without proper validation!DocumentationThe documentation can be found on theOcellaris web page.DevelopmentOcellaris is developed in Python and C++ onBitbucketby use of the Git version-control system. If you are reading this on github,
please be aware that you are seeing a mirror that could potentially be months
out of date. The github mirror is only updated sporadically—to trigger new
Singularity and Docker Hub container builds. All pull requests and issues
should go to the Bitbucket repository. If you want to contribute to Ocellaris,
please readthe guide to contributing.Ocellaris is automatically tested onCircleCIand the current CI build status is.Copyright and licenseOcellaris is copyright Tormod Landet, 2014-2019, and theOcellaris project
contributorsfrom 2019
and onwards. Ocellaris is licensed under the Apache 2.0 license, a permissive
free software license compatible with version 3 of the GNU GPL. SeeLicense of
Ocellarisfor the details.
Package: ocellus
ocellus-python-clientAutogenerated python client frombyte-motion/ProtobufDefsInstallationpipinstallocellusBuild and Deploy Manually$python3setup.pysdistbdist_wheel
$twinecheckdist/*
$twineuploaddist/*Example and DocumentationExamples can be found in theexamples folderMore documentation can be found here:https://docs.ocellus.io/remote-python-module-example/
Package: ocel-standard
# ocel-support
Support to the OCEL standard## Available commands:### Importing / Exporting / Validationlog_object = ocel.import_log(log_path): imports a log from the specified path (both JSON-OCEL and XML-OCEL).ocel.export_log(log_object, log_path): exports a log into the specified path (both JSON-OCEL and XML-OCEL).is_valid = ocel.validate(log_path, schema_path): validates the specified log against the schema (both JSON-OCEL and XML-OCEL).### Interfaceocel.get_events(log_object): returns a Python dictionary associating event identifiers to their
pr (activity, timestamp, object map, attribute map).ocel.get_objects(log_object): returns a Python dictionary associating object identifiers to their attributes
(object type, attribute map).ocel.get_attribute_names(log_object): returns a list of attribute names involved in events/objects of the log.ocel.get_object_types(log_object): returns a list of object types involved in events/objects of the log.ocel.get_version(log_object): gets the OCEL version (as a string) from the current OCEL object.ocel.get_global_event(log_object): gets the global values of attributes for the events.ocel.get_global_object(log_object): gets the global values of attributes for the objects.
Package: ocetrac
ocetracOcetrac is a Python 3.6+ packaged designed to label and track unique geospatial features from gridded datasets. The package is designed to accept data that have already been preprocessed, meaning that the data only contain values the user is interested in tracking. Ocetrac operates lazily with Dask so that it is memory uninhibited and fast through parallelized execution. We provide examples and demonstrate best practices as developed by theClimate Data Science Labat Columbia University / Lamont-Doherty Earth Observatory.When using this package, please cite the originalsoftware.InstallationCondaTo install the core package from conda-forge run:conda install -c conda-forge ocetracPyPITo install the core package run:pip install ocetrac.GitHubClone ocetrac to your local machine:git clone https://github.com/ocetrac/ocetrac.gitChange to the parent directory of ocetracInstall ocetrac withpip install -e ./ocetrac. This will allow
changes you make locally, to be reflected when you import the package in Python.How you can contributeYou can get involved by trying ocetrac, filingissuesif you find problems, and makingpull requestsif you make improvements.AcknowledgementsWe rely heavily onscikit-imageand its community of contributors.This work grew from a collabortion with NCAR during the ASP Graduate Visitor Program attended by Hillary Scannell. This project recieved continued support from the Leonardo DiCaprio Foundation, Microsoft, and the Gordon and Betty Moore Foundation.