Saravanan666/pypi-org huggingface dataset:
Package: simulation-classes-catherineannie13
Simulation Classes Package: Monopoly SimulationThis package,simulation_classes, provides a comprehensive suite of classes to simulate the classic board game Monopoly. It is designed to model the game's dynamics, including properties, players, and game logic, offering a robust foundation for creating and analyzing Monopoly strategies. Below is an overview of the key components and functionalities provided by this package.FeaturesMonopoly Board Simulation: A centralMonopolyBoardclass that encapsulates the game board, properties, and players, facilitating the simulation of full game rounds.Game Entities: Includes classes for various game entities such asChance,CommunityChest,FreeParking,Go,GoToJail,Jail,Player,Station,Strategy,RandomStrategy,Street,Tax, andUtility.Gameplay Mechanics: Implements methods for simulating the game's mechanics, such as moving around the board, buying properties, paying rent, drawing Chance and Community Chest cards, and handling special board spaces like Jail and Free Parking.Strategic Framework: The package includes aStrategyclass that can be extended to define custom gameplay strategies. ARandomStrategyclass is provided as an example.InstallationOption 1Clone this repository to your local machine:bashCopycode
gitclonehttps://github.com/catherineannie13/Capstone-Optimising-Monopoly-Gameplay-Strategies.gitcdmonopoly-mcts-aiEnsure you have Python 3.8 or later installed. It's recommended to use a virtual environment:bashCopycode
python-mvenvvenvsourcevenv/bin/activate# On Windows use `venv\Scripts\activate`Install the required dependencies:bashCopycode
pipinstall-rrequirements.txtOption 2Run pip install -ihttps://pypi.org/simple/simulation-classes-catherineannie13==0.0.1UsageHere is a simple example to get started with simulating a Monopoly game:fromsimulation_classes.monopoly_boardimportMonopolyBoardfromsimulation_classes.playerimportPlayer# Initialize the game boardboard=MonopolyBoard()# Create playersplayer1=Player("Player 1")player2=Player("Player 2")# Add players to the boardboard.add_player(player1)board.add_player(player2)# Start the game simulationboard.play_game()DocumentationFor a detailed description of all classes and methods, refer to the inline documentation provided within each module. TheMonopolyBoardclass documentation offers insights into the initialization parameters, attributes, and available methods for simulating the game and interactions between game entities.ContributingContributions to thesimulation_classespackage are welcome. Please refer to the project's repository for contribution guidelines and submit pull requests with any enhancements, bug fixes, or documentation improvements.Licensesimulation_classesis released under the MIT License. See the LICENSE file in the project repository for more information.
Package: simulations
What is this?This is a collection of Python modules containing functions to handel simulations.InstallationThis package can be installed using pip (recommended way):pip3 install simulationor by downloading and running:python3 setup.py installWeb sitesThe source code of this package is hosted on:https://github.com/jor-/simulationA Python wheel is available on:https://pypi.python.org/pypi/simulationAuthorJoscha Reimerjor@informatik.uni-kiel.deCopyrightCopyright (C) 2011-2016  Joscha Reimerjor@informatik.uni-kiel.deThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
Package: simulation-schedule
Python job scheduling for humans. Run Python functions (or any other callable) periodically using a friendly syntax.A simple to use API for scheduling jobs, made for humans.In-process scheduler for periodic jobs. No extra processes needed!Very lightweight and no external dependencies.Excellent test coverage.Tested on Python and 3.7, 3.8, 3.9, 3.10, 3.11, 3.12Usage$pipinstallscheduleimportscheduleimporttimedefjob():print("I'm working...")schedule.every(10).seconds.do(job)schedule.every(10).minutes.do(job)schedule.every().hour.do(job)schedule.every().day.at("10:30").do(job)schedule.every(5).to(10).minutes.do(job)schedule.every().monday.do(job)schedule.every().wednesday.at("13:15").do(job)schedule.every().day.at("12:42","Europe/Amsterdam").do(job)schedule.every().minute.at(":17").do(job)defjob_with_argument(name):print(f"I am{name}")schedule.every(10).seconds.do(job_with_argument,name="Peter")whileTrue:schedule.run_pending()time.sleep(1)DocumentationSchedule’s documentation lives atschedule.readthedocs.io.MetaDaniel Bader -@dbader_org-mail@dbader.orgInspired byAdam Wiggins’article“Rethinking Cron”and theclockworkRuby module.Distributed under the MIT license. SeeLICENSE.txtfor more information.https://github.com/dbader/schedule
Package: simulation-super-brownian-motions
Super Brownian Motion SimulationIntroductionThis Python script simulates super Brownian Motion (SBm), a stochastic process
where particles move randomly and branch under certain conditions. The script
offers functionalities to simulate the motion, plot the paths, save the images,
export the data, and generate an animation of the process in the gif format.Currently, all paths will branch or die after every fixed number of steps (default 100). More flexibility will be added in the future.RequirementsPython 3NumPyMatplotlibInstallationEnsure you have Python 3 installed. You can install the required packages using pip:pipinstallgit+https://github.com/yourusername/mypackage.gitor frompypipipinstallsimulation-super-brownian-motionsUsageCommand lineTo run the simulation with default parameters, simply execute the script:SuperBm--helpCommand Line ArgumentsYou can customize the simulation using the following command line arguments:-sor--seed: Random seed (default: 42), set to-1for random seed based on current time (for random outcome)-nor--num-steps: Number of steps in the simulation (default: 301)-uor--update-steps: Number of steps between branching events (default: 100)-por--branching-prob: Probability of branching at each step (default: 0.5)-cor--scale: Scale of the Brownian motion (default: 10.0)-dor--dpi: DPI parameter for the animation (default: 150)-aor--save-animation: Save the animation as a GIFExampleSuperBm--num-steps500--branching-prob0.7--scale15This command runs the simulation with 500 steps, a branching probability of 0.7, a Brownian motion scale of 15, and with default values for the other parameters. The animation won't be saved as a GIF.If you want the animation, run the following command:SuperBm--num-steps500--branching-prob0.7--scale15--save-animationOutputThe script will plot the paths of the Brownian motion.Paths will be exported as a CSV file.The plot will be saved as files in both PNG and JPET formats.With additional argument-aor--save-animation, the script will generate an animation of the process and save it as a GIF file.Within Python as a ModuleYou can use the script within Python as a module. The following example shows how to run the simulation with default parameters:importsimulation_super_brownian_motions.super_bm_simulationassbm# Create an instance of the classinstance=sbm.Branching_BM()# Use the instance and its methodsinstance.simulate()instance.plot_paths()ContributingContributions to this project are welcome! Please feel free to submit pull
requests or open issues to discuss potential improvements or features.AcknowledgmentsThanks for helpful discussions with Yumin Zhong and Panqiu Xia from Auburn University.LicenseMIT
Package: simula-tools-meetup-test
tools-meetup-testThis is a test package for the Simula tools meetupFree software: BSD licenseDocumentation:https://tools-meetup-test.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-11-07)First release on PyPI.
Package: simulert
SimulertHow often do your simulations fail moments after you close the terminal and head home
for the evening? Do you repeatedly check on your simulations to see how they're doing?
Have you ever left a long simulations for days longer than it needed?
This package is for configuring alerts for your simulations so you get told what's
happened, when it's happened and in the format that best suits you.InstallationAn early release has been made available onn Pypi so install via pip:pip install simulert. Or for the latest, clone this repository and adding it as a
development package with eitherpip install -e /path/to/simulertorconda develop /path/to/simulert.UsageThis package is architected similarly to Python's built-in logging package.
AnAlerterclass is instantiated withgetAlerter()and is triggered to send
alerts to all the handlers registered with it.Current handlers include a logger (default), an emailer and a slack client.TheAlertercurrently provides two ways to trigger alerts: most simply, calling thealertmethod with a message; and possibly more conveniently, with thesimulation_alertcontext wrapping the simulation code.Environment variable configurationThe handlers will take default arguments from environment variables so that this package
can be configured globally for the fewest lines to alerts.Email hander:SIMULERT_EMAIL_HOST: the host address of the email server to send from.SIMULERT_EMAIL_PORT: the connection port of the email server to send from.SIMULERT_EMAIL_AUTHENTICATION: comma-separated username and password to authenticate
to the email server.SIMULERT_EMAIL_SENDER: comma-separated sender name and email addressSIMULERT_EMAIL_RECIPIENT: comma-separated receiver name and email addressSlack handler:SIMULERT_SLACK_TOKEN: the token for the slack-bot used to send messages from.SIMULERT_SLACK_USERNAME: the username of the slack user to send messages to.ExampleThe verbose and transparent example:fromsimulertimportgetAlerterfromsimulert.handlersimportEmailer,Slackeremailer=Emailer("username","password",("Simulations","noreply_simulations@company.com"),("Data scientist","scientist@company.com"),"smtp.mailserver.company.com",)slacker=Slacker("slack_app_token","username")alerter=getAlerter().add_handler(emailer).add_handler(slacker)alerter.alert("Something special has happened in my code")which will send "Something special has happened in my code" to the log files, toscientist@company.comand to@usernameon slack.The convenient example, with environment variables configured:fromsimulertimportgetAlerterfromsimulert.handlersimportSlackeralerter=getAlerter("BigSims").add_handler(Slacker())withalerter.simulation_alert("super dooper sim"):run_simulation()which will send "BigSims: super dooper sim has completed without error." via slack oncerun_simulation()has completed.TODOTest logs.pyTidy up pyproject.toml to include only necessary filesAdd a changelogAdd a logging handler as an event source.
Package: simuleval
SimulEvalSimulEval is a general evaluation framework for simultaneous translation on text and speech. Full documentation can be foundhere.Installationgit clone https://github.com/facebookresearch/SimulEval.git
cd SimulEval
pip install -e .Quick StartFollowing is the evaluation of adummy agentwhich operates wait-k (k = 3) policy and generates random words until the length of the generated words is the same as the number of all the source words.cdexamples/quick_start
simuleval--sourcesource.txt--targettarget.txt--agentfirst_agent.pyLicenseSimulEval is licensed under Creative Commons BY-SA 4.0.CitationPlease cite as:@inproceedings{simuleval2020,title={Simuleval: An evaluation toolkit for simultaneous translation},author={Xutai Ma, Mohammad Javad Dousti, Changhan Wang, Jiatao Gu, Juan Pino},booktitle={Proceedings of the EMNLP},year={2020},}
Package: simunetcore
simunetcore PackageWhat issimunet®?Mathematical modeling and simulation as well as model-based optimization are fundamental tools in process engineering. Many questions are answered using these tools. These include, for example, the scale-up of plants and processes, the determination of optimum operating points, control strategies and operations, but in particular also questions of system integration in the development of complex technical systems that consist of a combination of various coupled subsystems.simunet®helps to decouple such systems and to solve the underlying mathematical models using waveform relaxation.Get more info onsimunet.org
Package: simuPOP
simuPOP is a forward-time population genetics simulation environment.
The core of simuPOP is a scripting language (Python) that provides
a large number of objects and functions to manipulate populations,
and a mechanism to evolve populations forward in time. Using this
R/Splus-like environment, users can create, manipulate and evolve
populations interactively, or write a script and run it as a batch
file. Owing to its flexible and extensible design, simuPOP can simulate
large and complex evolutionary processes with ease. At a more
user-friendly level, simuPOP provides an increasing number of built-in
scripts that perform simulations ranging from implementation of basic
population genetics models to generating datasets under complex
evolutionary scenarios.
Package: simuran
SimuranTo see more details than in the README, ourread the docssite, or the PhD thesis of Sean K. Martin.Installationpip install simuranMAC OSTo use the UI, you will need to perform at least the following -brew install libpng.It is possible you may also need the MAC command line developer tools.UsageObjectiveSimuran can help facilitate batch processing of many neural recordings in an easy to handle way.The main objects to setup are Recordings (containing all information relevant to an experiment, or part of an experiment) and RecordingContainers, which are a series of Recordings.
For instance, a RecordingContainer could represent all t-maze running speed, spikes, etc. and associated metadata, while a Recording is an individual t-maze session.
This can then support easy extraction of subcontainers, such as, all trials which were successful in mice expressing a particular gene.APIThe API is built around the Recording and RecordingContainer classes, for instance, one way to load an NWB file is as follows:importsimuranrecording=simuran.Recording(source_file=PATH_TO_NWB,loader=simuran.loader("NWB"))recording.load()recording.inspect()# See what was loadedThe Recording class is designed to be as flexible as possible, and can be used to load any data, as long as a loader is provided.
The loader is a class which takes a Recording object and loads the data into it.
Other modules include the analysis module, which allows multi-processing of analysis functions, and the base module, which contains the base classes for the API.
The plot module contains plotting functions for general use, and also some simple figure handling (auto garbage collection, etc.).
Finally, the bridge module contains Bridge class definitions, which are used to allow interoperability between different software tools and data formats in neuroscience.GUI - Visual node based editorHere, the focus is mostly on the Recording level, but multiple recordings can be bundled as blocks.Recordings are loaded and processed via Nodes which are established through the UI and run in a digraph fashion.
The UI is built using dearpygui, and supports a subset of the API via nodes, which can be expanded upon.ExamplesSome examples are provided in the examples folder.ContributingContributions are welcome, and any issues can be raised on the github page. Please feel free to reach out to me if you have any questions.LicenseSimuran is distributed under the GPL-3.0 License.InspirationNeuroChaT: Analysis toolset with GUI for NeuroscienceSpikeInterface · GitHubA set of python neuroscience scripts which rely on the NeuroChaT APIMNE: Magnetoencephalography (MEG) and Electroencephalography (EEG) in PythonSumatra - NeuralEnsembleSnakemakeUpdate coveragepytest .codecov -t ba31944a-6070-401e-a731-1bd2f92a5e55
Package: simutils
simutilsNote that this package is not yet implemented.UsageIt logs the argument of the function and other relevant information to a JSON file.>>>fromsimutilsimportlog_function>>>@log_function...defdouble_val(x):...returnx*2...>>>double_val(4)8Then the content of the JSON file will be:{"simulation_name":"double_val_20210216_141001","status":"success","computer_name":"MyComputer","python_version":"3.8.6 (tags/v3.8.6:db45529, Sep 23 2020, 15:52:53) [MSC v.1927 64 bit (AMD64)]","cwd":"current/working/directory","output_directory":"logs/double_val_20210216_141001","summary_filepath":"path/to/this/file","called_function":"double_val","start_time":"2021-02-16 14:10:02","end_time":"2021-02-16 14:10:03","simulation_time":"0:00:01.012345","args":{"x":4}}You can pass arguments to the decorator, and you can also decorate functions in a Python script.@log_function(git_repo=os.path.join(os.path.dirname(__file__),'..','..'),# git repository to log)deftriple_val(x):returnx*3To-Do'sSend a notification when a function execution is finished.Integrate with a native Python logger.Reproduce the original environment
Package: simvi
SIMVISIMVI (Spatial Interaction Modelling using Variational Inference) is a deep generative framework for disentangling intrinsic variation and spatially-induced variation in spatial omics data. SIMVI enables novel downstream analyses, including clustering and differential expression analysis based on disentangled representations, spatial effect identification, spatial effect attribution, and transfer learning on new measurements / modalities. SIMVI is implemented with scvi-tools.Read our preprint on BioRxiv:Dong, Mingze, et al. "SIMVI reveals intrinsic and spatial-induced states in spatial omics data". bioRxiv (2023).LinkSystem requirementsOS requirementsThe SIMVI package is supported for all OS in principle. The package has been tested on the following systems:macOS: Monterey (12.4)Linux: Ubantu (20.04.5)DependenciesSeesetup.cfgfor details.InstallationSIMVI requirespythonversion 3.7+.  Install directly from pip with:pip install simviThe installation should take no more than a few minutes on a normal desktop computer.UsageFor detailed usage, follow our step-by-step tutorial here:Getting Started with SIMVIDownload the dataset used for the tutorial here:Human MERFISH MTG data
Package: simvue
Simvue Python clientCollect metadata, metrics and artifacts from simulations, processing and AI/ML training tasks running on any platform, in real time.Website•DocumentationConfigurationThe service URL and token can be defined as environment variables:export SIMVUE_URL=...
export SIMVUE_TOKEN=...or a filesimvue.inican be created containing:[server]
url = ...
token = ...The exact contents of both of the above options can be obtained directly by clicking theCreate new runbutton on the web UI. Note that the environment variables have preference over the config file.Usage examplefrom simvue import Run

...

if __name__ == "__main__":

    ...

    # Using a context manager means that the status will be set to completed automatically,
    # and also means that if the code exits with an exception this will be reported to Simvue
    with Run() as run:

        # Specify a run name, metadata (dict), tags (list), description, folder
        run.init('example-run-name',
                 {'learning_rate': 0.001, 'training_steps': 2000, 'batch_size': 32}, # Metadaata
                 ['tensorflow'],                                                     # Tags
                 'This is a test.',                                                  # Description
                 '/Project-A/part1')                                                 # Folder full path

        # Set folder details if necessary
        run.set_folder_details('/Project-A/part1',                     # Folder full path
                               metadata={},                            # Metadata
                               tags=['tensorflow'],                    # Tags
                               description='This is part 1 of a test') # Description

        # Upload the code
        run.save('training.py', 'code')

        # Upload an input file
        run.save('params.in', 'input')

        # Add an alert (the alert definition will be created if necessary)
        run.add_alert(name='loss-too-high',   # Name
                      source='metrics',       # Source
                      rule='is above',        # Rule
                      metric='loss',          # Metric
                      frequency=1,            # Frequency
                      window=1,               # Window
                      threshold=10,           # Threshold
                      notification='email')   # Notification type

        ...

        while not converged:

            ...

            # Send metrics inside main application loop
            run.log({'loss': 0.5, 'density': 34.4})

            ...

        # Upload an output file
        run.save('output.cdf', 'output')

        # If we weren't using a context manager we'd need to end the run
        # run.close()LicenseReleased under the terms of theApache 2license.
Package: sim-web-visualizer
Web-Based Visualizer for Simulation EnvironmentsIsaacGym SimulatorSAPIEN SimulatorStatic URDF FileThis repository hosts a browser-based 3D viewer for physical simulators. It offers users the ability to observe
simulations directly within their web browser, as an alternative to the default visualizer that comes with the
simulator.The main feature of this repo is that you only need to modify a server lines of your code to port the
visualization on the default simulator viewer to the web visualizer. This feature is especially useful for visualizing
simulation on a headless server. For example, train and visualize the IsaacGym tasks
insidejupyter notebookon a remote server.InstallationFirst install ZeroMQ libraries on your system:aptinstalllibzmq3-dev# For ubuntubrewinstallzmq# For MacNote:this visualizer does not have a Python version requirement but
IsaacGym requires Python 3.6, 3.7, or 3.8gitclonehttps://github.com/NVlabs/sim-web-visualizercdsim-web-visualizer&&gitsubmoduleupdate--init--recursive
pipinstall-e.ExamplesIsaacGym Web VisualizerCheck theIsaacGym Examplefor information on running the
Web Visualizer onIsaacGymEnvs.SAPIEN Web VisualizerCheck theSAPIEN Examplefor information on running the
Web Visualizer onManiSkill2.URDF Web VisualizerCheck theURDF Examplefor information to visualize a static URDF file on Web
Visualizer.TroubleshootingCan "Upgrade" only to "WebSocket"This issue may arise if you have entered an incorrect URL into your browser. Ensure that the URL is in the
formathttp://YOUR_IP_ADDRESS:YOUR_PORT_NUM/static/. The/static/part of the URL is essential and should not be
omitted.404: Not FoundSimilar to the previous issue, the correct URL suffix should be/static/, and not/static. The trailing/is
mandatory and should not be omitted.Citing This RepoThis repository is a part of theAnyTeleop Project. If you use this work, kindly reference it
as:@inproceedings{qin2023anyteleop,title={AnyTeleop:AGeneralVision-BasedDexterousRobotArm-HandTeleoperationSystem},author={Qin,YuzheandYang,WeiandHuang,BinghaoandVanWyk,KarlandSu,HaoandWang,XiaolongandChao,Yu-WeiandFox,Dieter},booktitle={Robotics:ScienceandSystems},year={2023}}AcknowledgmentsThis repository is developed uponMeshCat. The URDF loader is
adapted fromyourdfpy.
We extend our appreciation to the developers and custodians of these open sources projects.License and DisclaimerWeb-Based Visualizer for Simulation Environments is released under theMIT License.