Saravanan666/pypi-org huggingface dataset:
Package: scenar-io
ScenarIOSCENe interfAces forRobotInput /Output.DescriptionScenarIOis a C++ abstraction layer to interact with simulated and real robots.It mainly provides the followingC++ interfaces:scenario::core::Worldscenario::core::Modelscenario::core::Linkscenario::core::JointThese interfaces can be implemented to operate on different scenarios,
including robots operating on either simulated worlds or in real-time.ScenarIO currently fully implementsGazebo ScenarIO,
a simulated back-end that interacts withIgnition Gazebo.
The result allows stepping the simulator programmatically, ensuring a fully reproducible behaviour.
It relates closely to other projects likepybulletandmujoco-py.A real-time backend that interacts with theYARPmiddleware is under development.ScenarIO can be used either from C++ (APIs)
or from Python (APIs).If you're interested to know the reasons why we started developing ScenarIO and why we selected Ignition Gazebo
for our simulations, visit theMotivationssection of thewebsite.InstallationScenarIO only supports a single distribution of the Ignition suite.
Visit ourSupport Policyto check the distribution currently supported.Then, install the supported Ignition suite following theofficial instructions.PythonExecute, preferably in avirtual environment:pipinstallscenar-ioC++You can either clone and install the standalone project:gitclonehttps://github.com/robotology/gym-ignitioncdgym-ignition/scenariocmake-S.-Bbuild/cmake--buildbuild/--targetinstallor include it in your CMake project withFetchContent.UsageYou can find some examples that show the usage of ScenarIO in theGetting Startedsection of thewebsite.ContributingPlease visit theLimitationssection of thewebsiteand check thegood first issueandhelp wantedissues.You can visit our community forum hosted inGitHub Discussions.
Even without coding skills, replying user's questions is a great way of contributing.
If you use ScenarIO in your application and want to show it off, visit theShow and tellsection!Pull requests are welcome.For major changes, please open adiscussionfirst to propose what you would like to change.Citation@INPROCEEDINGS{ferigo2020gymignition,title={Gym-Ignition: Reproducible Robotic Simulations for Reinforcement Learning},author={D. {Ferigo} and S. {Traversaro} and G. {Metta} and D. {Pucci}},booktitle={2020 IEEE/SICE International Symposium on System Integration (SII)},year={2020},pages={885-890},doi={10.1109/SII46433.2020.9025951}}LicenseLGPL v2.1or any later version.We vendor some resources from the Ignition code base.
For this reason, Gazebo ScenarIO is double-licensed with theApache License.
Package: scenario-builder
Tools to build scenario inputs from historical data or future assumptionsFree software: MIT licenseInstallationpip install scenario-builderYou can also install the in-development version with:pip install https://github.com/reegis/scenario_builder/archive/master.zipDocumentationhttps://scenario_builder.readthedocs.io/DevelopmentTo run all the tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelogv0.0.2 (2021-03-25)Add scenario builder for deflexv0.0.1 (2020-08-06)First release on PyPI.
Package: scenariogeneration
scenariogenerationThe Python scenariogeneration package is a collection of libraries for generating OpenSCENARIO (.xosc) and OpenDRIVE (.xodr) XML files.This combined package (which includes the former pyoscx, pyodrx) can be used to jointly generate OpenSCENARIO based scenarios with interlinked OpenDRIVE based road network maps. Nevertheless, it is still possible to separately generate OpenSCENARIO or OpenDRIVE files by using only a subset of the provided functionality.The package consists of thescenario_generatormodule and two Python subpackages,xosc(OpenSCENARIO) andxodr(OpenDRIVE), together with some support functionality for auto generation with parametrization as well as easy viewing withesmini.The user documentation can be foundhere, the API documentationhereand the change log inrelease_notes.mdPlease note that this is not an official implementation of either OpenSCENARIO or OpenDRIVE.CoverageAs of V0.11.0, the coverage of the modules varies:The xosc module has full coverage of OpenSCENARIO V1.0.0, and most of V1.1.0 and V1.2.0, if something is missing please raise an issue or make a pull request.The xodr module has coverage of basic roads, junctions, signals, and objects, based on OpenDrive (V 1.7.1).For more details se xodr_coverage.txt and xosc_missing_features.txtGetting Startedpip install scenariogenerationthen run any of the examples providedPrerequisitesBeen tested with Python >3.6.9.
With Python versions <3.7 the order of certain xml-elements might not be the same between generations.Installingpip install scenariogenerationUsagePlease see the user guide for more information:https://pyoscx.github.io/Running with esminiEsmini can be used to visualize the generated scenarios. Visithttps://github.com/esmini/esminiand follow the "Binaries and demos" section.
Your scenarios can be visualized directly by making use ofesminiin the following way:from scenariogeneration import esmini

def Scenario(ScenarioGenerator): ...


if __name__ == "__main__":
    s = Scenario()

    esmini(s,esminipath ='path to esmini', index_to_run = 'first')whereindex_to_runcan be 'first', 'random', 'middle' or an integer, and esmini will run that scenario/road for you.Related workesminiesminiis a basic OpenSCENARIO playerclothoidspyclothoids, used for construction and optimization of clothoids geometriesblender implementationblender + scenariogenerationAuthorsSeeAUTHORSfileData formatsThe wrappers is based on the OpenSCENARIO and OpenDRIVE standards.OpenDRIVEdescribes the static content of a scenario, like the road, lanes, signs and so on.OpenSCENARIOdescribes the dynamic content on top of a road network, e.g. traffic maneuvers, weather conditions, and so on.
Package: scenario-generator
PurposeThis repository generates scenarios modeling variations in miner behavior.  The scenarios generate time-indexed vectors of the following indicators of miner behavior:rb_onboard_powerrenewal_ratefilplus_rateThe scenarios can be fed to the filecoin-mecha-twin module to understand the effect of these parameters on indicators such as:Baseline crossingMiner ROIetc ...We can generate four classes of scenarios:StaticCurated scenarioForecastingMCMC forecastingAI based forecasting
Package: scenario-runner
Scenario Runner (sr)You could use a shell script, it's more advanced or you could use scenario runner.Install withpip install scenario-runnerCreate a file named 'sr.yml' in a directory where you want it to run.scenarios:run_my_tests:description:'Runallmytests'actions:-docker-compose:env:abc:abccompose_files:-'docker/docker-compose.yml'-'docker/test.docker-compose.yml'cmd:upargs:-'--force-recreate'-'-d'-'--abort-on-container-exit'-'--exit-code-from'-'test'Then you run the scenario withsr run_my_testsStructure of sr.ymlkey:valuescenarios:# all the scenarios with name as keyscenario_name:description:'Describethescenario.Thiscanbeviewedbyrunningsr--helpactions:#alltheactionsinthescenarioasalist-action_type:...Action typesdocker-composekeydescriptioncompose_filesAll compose files used when running docker-compose. Can be specified in action, scenario or globallycmddocker-compose [cmd] to run. See docker-compose --help for available commandsargsArguments for docker-compose after cmd. Can be a list of strings or stringshellkeydescriptioncmdcmd to runargsargs for cmd. Can be a list of strings or stringAction propertieskeydescriptionenvDictionary of environment variables to set before running command. Can be set in action, scenario or globally
Package: scenariotest
This testing helper-class was taken from a gist written by github user
‘bigjason’. It combines a prototypical test case with a list of dictionaries
(each a dict of keyword arguments) and transforms the two into a series of
unittest-compatible test cases. The advantage of this approach is that an
identical test can be applied to multiple scenarios with minimal repetition
of code, while still having each scenario tested independently and reported
to the user by the test runner.Example of usage can be found in the file xunit.py, or on
bigjason’s blog post which introduced the concept:<http://www.bigjason.com/blog/scenario-testing-python-unittest/>The original code this was based off of can be found on GitHub:<https://gist.github.com/856821/8966346d8e50866eae928ababa86acea6504bcee>
Package: scenario-testing-tools
List of componentsgenerate_refline: Generate a reference-line with matching normal-vectors and track-widths based on two bounds.get_scene_ego_traj: Extract the whole course of the ego-vehicle within an scenario.get_scene_timesample: Retrieve a time sample from a given (custom) csv-flavoured scenario file.get_scene_track: Retrieve a geometric or occupancy grid map from a given (custom) csv-flavoured scenario file.get_scene_veh_param: Retrieve vehicle specific parameters stored with the scenario (ggv and max. acc. of machines).interp_heading: Interpolate heading between given values, takes care of jumps near the switching point (-pi to pi).Contact person:Tim Stahl.
Package: scenario-tool-interface
Python interface to the scenario-toolhttps://www.wsc-scenario.org.auDescriptionThe Scenario Tool Interface provides an easy to use Python interface to the Scenario-Tool’s REST api.
It provides power users with the ability to create project, create complex workflows and run sensitivity
and uncertainty analysis. Combined with powerful python notebook’s and data analysis tools
such as pandas if provides a powerful tool to gain insights for complex integrated urban water management strategies.The API is in its early development stages and feedback on its usability and improvements to the functionality and
very welcome.Installpip install scenario-tool-interfaceDocumentationhttps://scenario-tool-interface.readthedocs.io
Package: scend
SCEndA matrix factorization method for single-cellPre-requirementspython3numpypandasscipyscikit-learnInstallationInstallation with pipTo install with pip, run the following from a terminal:pipinstallscendUsageBasic useimportscendimportpandasaspd# read your data, the rows in the data represent genes, and the columns represent cellsdata=pd.read_csv("data.csv",header=0,index_col=0)# create a SCEnd object which only return the imputed dataoperator=scend.SCEnd(n_features=10,estimate_only=True)# imputedata_imputed=operator.scend_impute(data)# create a SCEnd objectoperator=scend.SCEnd(n_features=10,estimate_only=False)# imputeres=operator.scend_impute(data)# get the resultsdata_imputed=res["estimate"]gene_matrix=res["gene latent factor matrix"]cell_matrix=res["cell latent factor matrix"]ParametersSCEnd(n_features=20,steps=10,alpha=1e-5,eps=10,noise_model="Fano",normalize=True,estimate_only=False)Parametersn_features : int, optional, default: 20The number of features during the matrix factorizaiton.steps : int, optional, default: 0.5The max number of iteration.alpha : float, optional, default: 1e-5gradient update step size. It can be so different with different dataset, please try more for a better result.eps : float, optional, default: 10The threshold at which the objective function stops updatingnoise_model: boolean, optional, default: "Fano"Our hypothetical noise model. We offer three options:CV : constant varianceFano : Fano factorCCV : constant coefficient of variationWe found that generally the fano model is the most stable.normalize : boolean, optional, default: TrueBy default, SCEnd takes in an unnormalized matrix and performs library size normalization during the denoising step. However, if your data is already normalized or normalization is not desired, you can set normalize=False.estimate_only : boolean, optional, default: FalseGenerally, the SCEnd returns a dictionary which contains the imputed matrix and gene latent factor matrix and cell latent factor matrix. If you have no need of the latent factor matrix, you can set estimate_only=True.
Package: scene
.. raw:: html<embed><p align="center"><img width="300" src="https://github.com/yngtodd/scene/blob/master/img/scene.png"></p></embed>--------------------------.. image:: https://badge.fury.io/py/scene.png:target: http://badge.fury.io/py/scene.. image:: https://travis-ci.org/yngtodd/scene.png?branch=master:target: https://travis-ci.org/yngtodd/scene=============================Scene=============================Guessing movie genres from script snippets.Documentation--------------For references, tutorials, and examples check out our `documentation`_.Installation------------From Sources:You can either clone the public repository:.. code-block:: consolegit clone git://github.com/yngtodd/sceneOr download the `tarball`_:.. code-block:: consolecurl  -OL https://github.com/yngtodd/scene/tarball/masterOnce you have a copy of the source, you can install it with:.. code-block:: consolepython setup.py install.. _tarball: https://github.com/yngtodd/scene/tarball/master.. _documentation: https://scene.readthedocs.io/en/latestDocumentation-------------The full documentation is at http://scene.rtfd.org.History-------0.0.1 (2019-02-11)++++++++++++++++++* First release on PyPI.
Package: scenedetect
Website:https://www.scenedetect.com/Documentation:https://www.scenedetect.com/docsGithub Repo:https://github.com/Breakthrough/PySceneDetect/PySceneDetect is a command-line tool and Python library which analyzes a video, looking for scene changes or cuts. PySceneDetect integrates with external tools (e.g.ffmpeg,mkvmerge) to automatically split the video into individual clips when using thesplit-videocommand and has several other features.Install:pip install--upgradescenedetect[opencv]Split video via CLI:scenedetect-ivideo.mp4split-videoSplit video using Python API:fromscenedetectimportdetect,AdaptiveDetector,split_video_ffmpegscene_list=detect('my_video.mp4',AdaptiveDetector())split_video_ffmpeg('my_video.mp4',scene_list)Licensed under BSD 3-Clause (see theLICENSEfile for details).Copyright (C) 2014-2023 Brandon Castellano.
All rights reserved.
Package: scenegen
scenegenAn animated scene generator. May be useful for testing video motion detectors.Scene descriptionFIXME: describe how to create scenes.DevelopmentCreate and activate a Python 3.7 virtualenv:$ python3.7 -m venv .venv && . .venv/bin/activateChange to a branch:$ git checkout -b my_branchInstall Poetry:https://python-poetry.org/docs/#installationInstall project deps and pre-commit hooks:$ poetry install
$ pre-commit install
$ pre-commit run --all-filesRemember to activate your virtualenv whenever working on the repo, this is needed
because pylint and mypy pre-commit hooks use the "system" python for now (because reasons).
Package: scene-graph-predictor-pc
点云场景图预测使用说明1. 环境依赖CUDA版本: 11.3
其他依赖库的安装命令如下：condacreate-npy38python=3.8pipinstalltorch==1.12.1+cu113torchvision==0.13.1+cu113torchaudio==0.12.1--extra-index-urlhttps://download.pytorch.org/whl/cu113
pipinstalltorch-scatter-fhttps://pytorch-geometric.com/whl/torch-1.12.1+cu113.html
pipinstalltorch-sparse-fhttps://pytorch-geometric.com/whl/torch-1.12.1+cu113.html
pipinstalltorch-spline-conv-fhttps://pytorch-geometric.com/whl/torch-1.12.1+cu113.html
pipinstalltorch-geometric2. 下载安装pipinstallscene-graph-predictor-pc3. 使用说明importscene_graph_predictor_pcimporttrimeshplydata=trimesh.load('scene/scene0/labels.instances.align.annotated.v2.ply',process=False)model=scene_graph_predictor_pc.SceneGraphPredictor()# model 加载数据model.load('checkpoint')# 模型预测
Package: scenepic
All platforms have good support for 2D images, with well-recognized formats
such as PNG and JPEG that can be viewed out of the box (no installation)
and shared trivially.However, while many formats exist for 3D data, none are well-supported
without installation of tools such as MeshLab, Blender, etc.ScenePic was created for 3D computer vision researchers such as those
working onHoloLensandMeshat Microsoft.
It was designed to be a lightweight, reuseable 3D visualization
library, with the following desiderata in mind:Make experimentation with 3D data near effortlessIncredibly easy to create and share 3D resultszero-install sharing of detailed 3D results using HTMLbased on modern web standards so usable with any modern browser
(tested in Edge, FireFox and Chrome)embeddable in other HTML documentsPerformantbased on WebGLHigh quality visualsWorks both offline or interactively in client-server setupSimple, clean APIfriendly Python front-endbasic mesh json file formatother language front ends easy to add
Package: scenera.node
Scenera Node SDKScenera Node SDK is a Python library intended to interact easily with theSceneMarkand to build AI nodes easily according to the rules of the Scenera PaaS.Table of ContentsInstallationUsageExample NodeDocumentationLicenseSupportInstallationYou can install Scenera Node SDK from PyPI:pipinstallscenera.nodeThis package supports Python 3.6+.UsageHere's a basic example of how to use Scenera Node SDK:importloggingfromflaskimportFlask,requestfromflask_corsimportCORSfromscenera.nodeimportSceneMarkfromscenera.node.loggerimportconfigure_logger## loggerlogger=logging.getLogger(__name__)logger=configure_logger(logger,debug=True)app=Flask(__name__)CORS(app)NODE_ID="my_example_node"@app.route(f'/{NODE_ID}/1.0',methods=['POST'])defnode_endpoint():## The first thing we do is load the request into the SceneMark objectscenemark=SceneMark(request=request,node_id=NODE_ID,disable_linter=False)"""Your node goes here"""## We automatically return the SceneMark back to the NodeSequencerscenemark.return_scenemark_to_ns()return"Success"Example NodeComing soon.DocumentationYou can find the complete API documentation atour documentation website.LicenseThis project is licensed under the terms of the MIT license. SeeLICENSEfor more details.SupportIf you encounter any issues, please report them via the issue tracker on GitHub.For more general questions or discussions, you can reach out to us atdirk.meulenbelt@scenera.net.
Package: scene-text
Scene Text Detection and RecognitionThis project packages scene text algorithms for easy usage. Scenes as in photos are much harder for text detection and recognition than doing the same for scanned documents. The latter is mostly referred to as OCR and it is a well solved problem. Note that due to the usage of Deep Learning algorithms, text detection and recognition are rather slow, in particular on CPU-only machines and for images with a large number of words. Accuracies have reached an impressive level but are still below human performance. Currently, the following algorithms are available.EASTis used for detection, where the implementation is mostly copied fromJan Zdenek.MORANis used for recognition, where the implementation is mostly copied fromCanjie Luo.Installation:pip install scene_textBasic usage from Python:import cv2

# The first import after installation can take a little longer as it downloads
# pre-trained models and compiles some native code.
from scene_text import AllWordsRecognizer

# initialize models
pipeline = AllWordsRecognizer()

# read an image
img = cv2.imread('path/to/my/image/file')[:, :, ::-1]

# detect and recognize all words in the image
words, boxes = pipeline.get_all_words(img)Basic usage from command line:scene_text my/input/image/folder my/output/folderIf you have trouble with the complex dependencies try Docker:docker build -t scene_text .

docker run --rm -i -t -v ${PWD}:/scene_text scene_text

# ...
Package: scenic
ScenicA compiler and scenario generator for the Scenic scenario description language.
Please see thedocumentationfor installation instructions, as well as tutorials and other information about the Scenic language, its implementation, and its interfaces to various simulators.For a description of the language and some of its applications, seeour journal paper, which extends ourPLDI 2019 paper(note:the syntax of Scenic has changed slightly since the PLDI paper, and many features such as support for dynamic scenarios have been added; these are described in the journal paper).
Scenic was designed and implemented by Daniel J. Fremont, Edward Kim, Tommaso Dreossi, Shromona Ghosh, Xiangyu Yue, Alberto L. Sangiovanni-Vincentelli, and Sanjit A. Seshia.If you have any problems using Scenic, please submit an issue toour GitHub repositoryor contact Daniel atdfremont@ucsc.edu.The repository is organized as follows:thesrc/scenicdirectory contains the package proper;theexamplesdirectory has many examples of Scenic programs;thedocsdirectory contains the sources for the documentation;thetestsdirectory contains tests for the Scenic compiler.
Package: scenographer
scenographerscenographeris a Python script that can create a subset of a postgres database, without losing referential integrity.The goal is to be able to spawn data-correct databases to easily create new environments that can be used for testing and / or demo'ing.Relevant links:DocumentationInstallationUsepipto installscenographer.pipinstallscenographerUsageScenographer requires a configuration file. An empty one, to serve as a starting point, is available by runningscenographer empty-config.After adjusting the configuration file, it's easy to start the sampling run:scenographerbin/scenographersampleconfig.jsonor if the schema doesn't need to be recreated in the target database:scenographerbin/scenographersampleconfig.json--skip-schemaConfigurationSOURCE_DATABASE_URLThe connection string for the source database. Only Postgres is supported.TARGET_DATABASE_URLThe connection string for the target database. Only Postgres is supported.IGNORE_RELATIONSScenographer works by traversing a DAG graph created from the foreign key constraints of the database.
However, it's not always the case that the database forms a DAG. To handle those cases, some foreign keys can be ignored by adding exceptions in this form:IGNORE_RELATIONS=[{"pk":"product.id","fk":"client.favorite_product_id"}]EXTEND_RELATIONSIn other ocasions, the actual foreign key constraint is not present in the database, although it exists in the business-side of things (like Rails does it).
Additional relations can be added to handle those cases. The relations take the same format ofIGNORE_RELATIONS.IGNORE_TABLESSome tables areextra. They may not matter, they may require a special solution or they are part of different components. Either way, you can ignore them.QUERY_MODIFIERSFor some cases, it's useful to tap into the actual queries being made. For that, you can add an entry here. Here's an example:QUERY_MODIFIERS={"_default":{"conditions":[],"limit":300},"users":{"conditions":["email ilike '%@example.com'"]},}Each entry is a table, with the exception of_defaultwhich is applied to all queries. Its values can have aconditionsand/orlimitkey. For conditions you can write plainsql.OUTPUT_DIRECTORYAt some point, the data is converted into CSV files to be imported into postgres. This is the directory for said CSV files. If you don't care about it, feel free to ignore. If it's not declared, it will create and use a temporary dictory instead.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