Saravanan666/pypi-org huggingface dataset:
Package: tile-match-gym
Tile Matching Reinforcement Learning EnvironmentsWelcome to the Reinforcement Learning Environments for Tile Matching Games repository! Here you can find a collection of tile matching game environments (like Bejeweled or Candy Crush), poised to push reinforcement learning research forwards.This genre of games is characterised by the following features, which we find useful for reinforcement learning research:Large action spacesIntuitive action hierarchiesProcedurally generated levelsStructured complex stochasticity in transition dynamicsInstallationYou can install the package via pip:pip install tile-match-gymExample UsageWe follow the the Farama Foundation Gymnasium API:from tile_match_gym.tile_match_env import TileMatchEnv

env = TileMatchEnv(
  num_rows=10, 
  num_cols=10, 
  num_colours=4, 
  num_moves=30, 
  colourless_specials=[], 
  colour_specials=[], 
  seed=2
  )

obs, _ = env.reset()

while True:
    action = env.action_space.sample()
    next_obs, reward, done, truncated, info = env.step(action)
    if done:
        break
    else:
      next_obs = obsCitationWe'd love it if you use our package for your research! If you do use code from this repository please cite us as below:@software{tile_match_gym,
  author = {Patel, Akshil and Elson, James},
  title = {{Tile Matching Game Reinforcement Learning Environments}},
  url = {https://github.com/akshilpatel/tile-match-gym},
  version = {0.0.1},
  year = {2023}
  }
Package: tile-operator
tile-operatorusageCLItile download$pythonto.py-vdownloadhttps://tile.openstreetmap.jp/{z}/{x}/{y}.pngtests/data/test.geojson18TileDownloadOptions:tile_url=https://tile.openstreetmap.jp/{z}/{x}/{y}.pngfile_path=tests/data/test.geojsonzoom_level=18100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████|30/30[00:05<00:00,5.11it/s]help$pythonto.py--helpUsage:to.py[OPTIONS]COMMAND[ARGS]...Tileoperatorv0.0.4

Options:--versionShowtheversionandexit.-v,--verboseverbosemode--helpShowthismessageandexit.

Commands:operateTileOperationpythoninstall$pipinstalltile-operatorfromtile_operator.operateimportTileOperateto=TileOperate(zoom_level=18,)tile_url="https://tile.openstreetmap.jp/{z}/{x}/{y}.png"to.set_tile_list()to.download_all_tiles(tile_url)test$pytest-qstestsdevelopmentsetup$poetryconfigvirtualenvs.in-projecttrue$pyenvglobal3.9# Version 3.8 or higher will work, but 3.9 is recommended.$python-mvenv.venv
$source.venv/bin/activate
$python-mpipinstall--upgradepip
$poetryinstall
$poetryshellpublish$poetrybuild
$poetrypublish
Package: tilequeue
# tilequeueA tile generator, used by itself for asyncronous tile generation or with [tileserver](https://github.com/tilezen/tileserver/) for serving tiles.## InstallationWe recommend following the vector-datasource [installation instructions](https://github.com/tilezen/vector-datasource/wiki/Mapzen-Vector-Tile-Service)._Note: Installation has been tested using Python 2.7 and results with other versions may vary._In addition to the dependencies in [requirements.txt](requirements.txt), tileserver requiresPostgreSQL client-side development library and headers (for psycopg)GEOS libraryThese can be installed on Debian-based systems with` sudoapt-getinstalllibpq-devlibgeos-c1v5`Then install the python requirements withpip install -Ur requirements.txtThen:python setup.py develop## ConfigurationSee [config.yaml.sample](https://github.com/tilezen/tilequeue/blob/master/config.yaml.sample)## Layer definitionsTo understand the language tilequeue layer definitions, it’s best to look at the [Tilezen vector-datasource](https://github.com/tilezen/vector-datasource)## LicenseTilequeue is available under [the MIT license](https://github.com/tilezen/tilequeue/blob/master/LICENSE.txt).
Package: tilereduce
tilereduce==========A framework for writing [tile-reduce](https://github.com/mapbox/tile-reduce)map scripts in Python.NOTE: This library is experimental and under active development. No officialrelease has been created.Usage-----First read the documentation at [tile-reduce](https://github.com/mapbox/tile-reduce).`tile-reduce-py` allows you to write the map script in Python. The reducer isstill Javascript.```import mapbox_vector_tileimport tilereduceclass BuildingRoadCount(tilereduce.TR):def mapper(self, x, y, zoom, data):if data is None:return 0# Decode the raw binary protocol buffer datatd = mapbox_vector_tile.decoder.TileData(2048)tile = td.getMessage(data)count = 0if tile.get('buildings'):count += len(tile['buildings'])if tile.get('roads'):count += len(tile['roads'])return countif __name__ == '__main__':BuildingRoadCount.main()```The reduce script is identical as the original Node example except the `map`argument is now the path to the Python map script.
Package: tiler-swift
tiler-swiftTiler Swift, the swiftest quadkey tiler in the wild west.Features✔ Get quadkey tiles from raster✔ Simple and blazingly fastTable of ContentsOverviewLibraryCommand LineDevelopmentLicenseOverviewThis project provides a Python library and a thin command line wrapper on top of it to cut quadkey raster tiles.Quadkey tiles are raster files of equal size (width, height) on a specific zoom level; the coordinate reference system is the Mercator Projection.
The quadkey identifier is constructed by dividing the world into four, then dividing each cell into four again, and so on, recursively.Seehttps://labs.mapbox.com/what-the-tile/https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-systemhttps://wiki.openstreetmap.org/wiki/Slippy_map_tilenameshttps://wiki.openstreetmap.org/wiki/Slippy_MapLibraryThequadkeys(dataset, z, nodata=0, tile_filter_fn=None)function provides a generator yielding quadkeys and their associated data.Argsdataset: the rasterio dataset to cut quadkeys fromz: the zoom level to cut quadkeys atnodata: the value to use for fillingtile_filter_fn: a functionmercantile.Tile -> boolto filter the quadkey generator withYields a tuple withquadkey: the quadkey name e.g.1202121012data: the pixel data as a numpy ndarrayprofile: the rasterio profile with metadata e.g. transformation for geo-referencingExample usage:forquadkey,data,profileinquadkeys(dataset,z=args.zoom):print(quadkey)withrasterio.open(args.out,"w",**profile)asout:out.write(data)Command Lineusage: tiler-swift [-h] -z ZOOM -o OUT [-n NODATA] raster

cuts quadkeys from raster

positional arguments:
  raster                raster to cut quadkeys from

optional arguments:
  -h, --help            show this help message and exit
  -z ZOOM, --zoom ZOOM  zoom level to cut quadkeys at (default: None)
  -o OUT, --out OUT     directory to write quadkeys to (default: None)
  -n NODATA, --nodata NODATA
                        nodata value to use for filling at edges (default: None)Example usage:quadkeys input.tif -o output.tif -z 10 -n 0DevelopmentFor developmentmake

make run
$ tiler-swift --helpInside the self-contained reproducible containerflake8 rfq
mypy rfq
pytestLicenseCopyright © 2020 robofarmDistributed under the MIT License (MIT).
Package: tilesman
Tilesman is designed to create a hierarchy of tiled representations of the supplied photos.
Starting with the photo in its original pixel resolution, Tilesman will create the minimum
number of tiles, as per dimensions supplied as arguments, and save them in a numbered folder.
After that, the photo will be resized to 1/2 of its original size and the tiling process
will be applied recurvively until the photo reaches the minimum size of 1 x 1 pixels. At this
stage, a hierarchy of folders is expected to exist, named from “0” (1 x 1 pixels image,
one tile) up to the highest numbered folder (original size photo, maximum number of tiles).
Tiles can have dimensions smaller than the requested sizes, when they are extracted from the
edges of x and y axes.Pre-requisitesPython 3.3+pip 9.0.0+Pillow 5.0.0+Installationpip install tilesmanUsage (in your Python code)Processing a single photofrom tilesman.core import photo_tilingphoto_tiling(‘/path/to/the/photo’, tile_max_width, tile_max_height)Processing several photos in a directory (parallel processing)from tilesman.core import batch_photo_tilingbatch_photo_tiling(‘/path/to/the/photo/directory’, tile_max_width, tile_max_height)Usage (as a command line utility)For detailed argument options:tilesman -hTo tile a phototilesman -p /path/to/the/photo_or_directory -w <tile_max_width> -e <tile_max_height>Testscd /where/you/saved/tilesman/sourcepython -m unittest -v tilesman/tests/test_*
Package: tiletanic
Tiletanic is a library for making and using geospatial tiling schemes.  It’s goal is to provide tooling for dealing with the conversion between a tile specified in  as (row, column, zoom level),  geospatial coordinates, or quadkeys.  It also provides functionaly for taking an input geometry and figuring out what tiles cover it.Tiletanic is MIT licensed.Full documentation is hostedhere.Installation is easy:pip install tiletanicThe only dependency isshapely, and to install that, you’ll needGEOSinstalled (usually in your package manager).MotivationYou may be familar with theWeb Mercator(or Spherical Mercator, Google Tiles, etc) tiling scheme, which is the most commonly encountered tiling scheme on the web.  There are good tools out there for dealing specifically with this projection, for instanceMercantilefits the bill.  If you’re dealing exclusively with this projection, you might get better mileage with them!One oddity of Web Mercator is that coordinates are usually expressed in geographic (longitude, latitude) coordinates that live on the ellipsoid (WGS84) rather than in units of the Web Mercator projection (meters).  Dealing with this kind of conversion is exactly whatMercantileand its like were made to handle.Tiletanic’s use cases are a bit different:What do you do if your data is already in some projection?  For instance, you might want to know what tile covers a point specified in the Web Mercator projection without first converting back to WGS84.  Tiletanic can help.AtDigitalGlobe, our imagery is often projected into many other projections (UTM, Geographic, etc) and it is often times extremely convienent to organize raster data into a tiled format before proceeding with processing (a single “strip” from one of our satellite collects can easily be 100km long!).  When dealing with different projections, the user typically needs to impose their own tiling scheme.  Tiletanic provides an easy way for you to define you’re own scheme and get a lot of tiling functionality right out of the gate.
Package: tile-tools
Tile ToolsCollection of tools useful for navigating Mapbox (and similar) tiles.Most of these tools were written by Mapbox in JavaScript. I've ported them into Python with minimal modification.ContentstilebeltUtility functions for working with tiles.This is a complete Python port of Mapbox's@mapbox/tilebelt.There are some minor differences in the API.
See thesubmodule readmefor more details.coverGiven a GeoJSON Geometry and a zoom level, generate the minimal set of Mapbox(x, y, zoom)tiles that cover this geometry.This is a re-implementation of Mapbox's@mapbox/tile-cover.
The implementation started out as a port, however the originally library is not passing all of its own tests.
The API has been re-implemented here with a slightly different approach, and all of the equivalent tests are now passing.Seesubmodule readmefor details.coordscoords.tilecoords2lnglatTransform Mapbox's relative tile(x, y)coordinates into longitude/latitude degrees.distancedistance.haversineCompute the distance between two points on the globe using the haversine formula.RenderingFor debugging and general interest, the cover algorithm can be visualized with thescripts/render.pyscript.It requires thatgdalandImageMagickare installed. Then, run:poetryinstall--withrenderAn example usage is rendering thedegenringtest fixture at zooms 1-14.
The output will be stored as a GIF inrender.gif.cattests/fixtures/degenring.geojson|poetryrunpythonscripts/render.py--zmin1--zmax13--outrender.gifDevelopmentSet up the environment withpoetry:poetryinstall--withdev
poetryrunpre-commitinstallTestspoetryrunpytest
Package: tileviewer
Quick (and dirty) tile viewerpython -m tileviewer <tiles.json>open browser and go tohttp://127.0.0.1:5000In addition to json files, data can be read from a mongodbpython -m tileviewer mongo:<host>:<database>:<collection>and the serving host (default: 0.0.0.0) and port (default: 5000) can be set:python -m tileviewer <tiles.json> <host> <port>See tileviewer/db/dbbuilder.py for an example script to build a
tilestore database.See jobs for example scripts to run sever renderers on a cluster. Be sure to
set the TILESERVER_DIR environment variable so that all renderers can
locate other renderers.
Package: tiling
Image Tiling UtilsMinimalistic set of image reader agnostic tools to easily iterate over large imagesExample 1Let's iterate over a large image with overlapping tiles of the
same size tiles in pixels. At boundaries we add "no-data" pixels.
Let's assume the data access is provided with an example functiondefread_data(x,y,width,height,out_width=None,out_height=None):out_width=widthifout_widthisNoneelseout_widthout_height=heightifout_heightisNoneelseout_heightimg.read(x,y,width,height,out_width,out_height)Thus, overlapping tiles can be extracted asfromtilingimportConstStrideTilestiles=ConstStrideTiles(image_size=(500,500),tile_size=(256,256),stride=(100,100),origin=(-100,-100),scale=1.0,include_nodata=True)print("Number of tiles:%i"%len(tiles))forextent,out_sizeintiles:x,y,width,height=extentdata=read_data(x,y,width,height,out_width=out_size[0],out_height=out_size[1])print("data.shape:{}".format(data.shape))# Access a tile:i=len(tiles)//2extent,out_size=tiles[i]Example 2Let's iterate over a large image with overlapping tiles of the same size in pixels.
In this case we prefer to not going outside the input image and fill tiles withnodata.
In this situation, overlapping is not constant.
Let's assume the data access is provided with an example functiondefread_data(x,y,width,height,out_width=None,out_height=None):out_width=widthifout_widthisNoneelseout_widthout_height=heightifout_heightisNoneelseout_heightimg.read(x,y,width,height,out_width,out_height)Thus, overlapping tiles can be extracted asfromtilingimportConstSizeTilestiles=ConstSizeTiles(image_size=(500,500),tile_size=(256,256),min_overlapping=15,scale=1.0)print("Number of tiles:%i"%len(tiles))forextent,out_sizeintiles:assertout_size[0]==tiles.tile_size[0]assertout_size[1]==tiles.tile_size[1]x,y,width,height=extentdata=read_data(x,y,width,height,out_width=out_size[0],out_height=out_size[1])print("data.shape:{}".format(data.shape))# Access a tile:i=len(tiles)//2extent=tiles[i]Installation:from pippipinstalltilingfrom sourcespipinstallgit+https://github.com/vfdev-5/ImageTilingUtils.gitExamplesFor more practical examples, seenotebooks
Package: tiling3d
Tiling 3DThis package is for tiling cuboids with tiles/polyominos.InstallationUse the package managerpipto install Tiling 3D.pipinstalltiling3dUsageCreate a cuboid with some parts filled in. The create tiles or use tiles from tiles.py.importnumpyasnpfromtiling3d.tiling_objectsimportCuboid,TilingProblemfromtiling3d.tilesimportget_tiles_by_namefromtiling3d.tiling_solverimportget_all_solutionsfromtiling3d.visualizationimportplot_solutionboard=Cuboid("Test",np.array([[[0,0,0],[0,0,0],[0,1,0]],[[0,0,0],[0,0,0],[0,1,0]]]))tiles=get_tiles_by_name(["t16","t8","t7","t10"])problem=TilingProblem(tiles,board)solutions=get_all_solutions(problem)forsolutioninsolutions:plot_solution(solution)ContributingPull requests are welcome. For major changes, please open an issue first
to discuss what you would like to change.LicenseMIT
Package: tilmedia
TILMedia Suite provides methods of calculation, which express the thermophysical properties of
incompressible liquids, ideal gases and real fluids containing a vapor liquid equilibrium (VLEFluid). Methods
for calculating the properties of mixtures are also included. TILMedia provides a comprehensive
range of different substances, including our own highly efficient and accurate real-time substance
property implementations.(https://www.tlk-thermo.com/index.php/en/software/tilmedia-suite)Example for a gas:>>> import tilmedia
>>> gas = tilmedia.Gas('VDI4670.DryAir')
>>> gas.set_pTxi(1e5, 300)
>>> round(gas.d, 6)
1.161034
>>> gas.set_Txi(300)
>>> round(gas.cp, 6)
1004.990552
>>> gas.set(p=1e5, T=300)
>>> round(gas.d, 6)
1.161034
>>> gas.set_Txi([300, 350, 400])
>>> gas.cp.round(6)
array([1004.990552, 1008.342171, 1013.626381])Example for a liquid:>>> import tilmedia
>>> liquid = tilmedia.Liquid('TILMedia.Water')
>>> liquid.set_Txi(300)
>>> round(liquid.d, 6)
996.425346
>>> liquid.set_pTxi(1e5, 300)
>>> round(liquid.s, 6)
394.977757
>>> liquid.set(p=liquid.p, T=300)
>>> round(liquid.s, 6)
394.977757
>>> liquid.set_Txi([300, 310, 320])
>>> liquid.cp.round(6)
array([4180.308149, 4177.312533, 4177.805418])Example for a VLEFluid:>>> import tilmedia
>>> vleFluid = tilmedia.VLEFluid('TILMedia.R134a')
>>> vleFluid.set_pTxi(1e5, 300)
>>> round(vleFluid.d, 6)
4.173095
>>> round(vleFluid.vle.T_l, 6)
246.788812
>>> vleFluid.set_pxi(2e5)
>>> round(vleFluid.vle.T_l, 6)
263.073728
>>> vleFluid.set(T=vleFluid.sat.T_dew)
>>> round(vleFluid.sat.p_dew, 1)
200000.0
>>> vleFluid.set_phxi(1e5, [350e3, 360e3, 370e3])
>>> vleFluid.d.round(6)
array([6.106462, 5.79392 , 5.511813])
Package: tils
TilsCollection of Python utility functionsDeployment to PyPiCreate a.envfile with the following content (add pypi token within quotes).PYPI-USER="__token__"PYPI-TOKEN=""Create a virtual environment and install the dependencies.Linuxpython-mvenvvenvsourcevenv/bin/activate
pipinstall-rrequirements.txtWindowspython-mvenvvenv
venv\Scripts\activate
pipinstall-rrequirements.txtRun deployment script.pythondeploy.py
Package: tilt-ble
Tilt BLEParser for Tilt BLE devicesInstallationInstall this via pip (or your favourite package manager):pip install tilt-bleContributors ✨Thanks goes to these wonderful people (emoji key):This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditsThis package was created withCookiecutterand thebrowniebroke/cookiecutter-pypackageproject template.
Package: tilted
TiltedTilted is a lightweight, open-source Python package with a simple interface for poker hand evaluation & comparison.InstallationWith Poetry:poetryaddtiltedWith Pip:pipinstalltiltedBasic UsageTilted can be used to generate, evaluate and compare 5-card poker hands.Hand GenerationTo generate a random hand:fromtiltedimportDeck,Handdeck=Deck()unknown_hand=Hand(deck.draw_many(5))unknown_hand# <Hand: 8♦ T♠ T♣ Q♣ K♥>unknown_hand.hand_rank# <HandRank.PAIR: 2>Hand EvaluationTo evaluate an unknown hand:fromtiltedimportCard,CardRank,CardSuit,Handunknown_hand=Hand([Card(CardRank.TEN,CardSuit.SPADES),Card(CardRank.JACK,CardSuit.SPADES),Card(CardRank.QUEEN,CardSuit.SPADES),Card(CardRank.KING,CardSuit.SPADES),Card(CardRank.ACE,CardSuit.SPADES),])unknown_hand.hand_rank# <HandRank.ROYAL_FLUSH: 10>Hand ComparisonTo compare two hands:fromtiltedimportCard,CardRank,CardSuit,Handroyal_flush=Hand([Card(CardRank.TEN,CardSuit.SPADES),Card(CardRank.JACK,CardSuit.SPADES),Card(CardRank.QUEEN,CardSuit.SPADES),Card(CardRank.KING,CardSuit.SPADES),Card(CardRank.ACE,CardSuit.SPADES),])straight_flush=Hand([Card(CardRank.NINE,CardSuit.HEARTS),Card(CardRank.TEN,CardSuit.HEARTS),Card(CardRank.JACK,CardSuit.HEARTS),Card(CardRank.QUEEN,CardSuit.HEARTS),Card(CardRank.KING,CardSuit.HEARTS),])royal_flush>straight_flush# TrueGame & DealingTo create a game, deal cards to the board and determine the winning player:fromtiltedimportGamenum_players=2game=Game(num_players)game.deal_next_street()game.board.flop# [A♦, A♠, A♣]game.deal_next_street()game.board.turn# K♣game.deal_next_street()game.board.river# Q♣game.board.cards# [A♦, A♠, A♣, K♣, Q♣]game.players[0].name# "Player #1"game.players[0].hole_cards# [A♥, K♥]game.players[1].name# "Player #2"game.players[1].hole_cards# [T♦, Q♦]game.get_winner()# [<Player: Player #1>]NOTE:get_winnerreturns a list to account for split pots (when two players have the winning hand).RoadmapFeaturesHand evaluationHand comparisonDeck supportBoard & dealing (Flop, Turn, River)Player supportFull board & hole card evaluationButtons & bettingGame state serializationSimulations API and/or simulation examplesDeploymentCIBadges
Package: tiltlib
tiltlibTilt TEM sample holdersInstallationTo install, just runpip install tiltlibin your favorite environment.ContributingDownload the code withgitclonehttps://github.com/viljarjf/tiltlib.git[Optional] Create an environment:condacreate--nametiltlib_env
condaactivatetiltlib_envInstall:cdtiltlib
pipinstall-e.Open a pull request tohttps://github.com/viljarjf/tiltlib.
Package: tiltx
TiltXFeature extraction from mobile phone motion sensor dataThis repository implements a method which extracts some of the key features from mobile phone motion sensor data.Att=0a visual stimulus appears on the screen. As the response, a participant (person holding the phone) is required to tilt the phone in a specific direction (left, right, up, or down). Once the roll or picth angle reaches 0.5 radians (t=T>0), the movement is completed.Tis the event time registered by the app. The rotaion along the third axis (yaw)does notaffect the outcome of the task, hence it is neglected.The features extracted by TiltX are: reaction time, L1 norms, maximal deviation, number of turning points, and sample entropy.UsageThese steps introduce how to useTiltX.Input dataTheDataGeneratoris a utility class that generates sample datasets.fromtiltx.data_generatorimportDataGeneratort,alpha,beta=DataGenerator.example(1)Note:t,alpha, andbetaneed to be equal length arrays.Extract featuresTheFeatureExtractorextracts key features from the data.fromtiltx.feature_extractorimportFeatureExtractorfeatures=FeatureExtractor(t,alpha,beta,RT_method='cumsum',correct='up')Note:cumsumis a method for reaction time detection andcorrectis the direction in which the phone should be tilted in order to successfully complete the task.print('Reaction time:%.3f'%(features.RT))print('L1-norm of the triggering axis:%.3f'%(features.L1_x))print('L1-norm of the remaining (non-triggering) axis:%.3f'%(features.L1_y))Reactiontime:0.669L1-normofthetriggeringaxis:0.492L1-normoftheremaining(non-triggering)axis:0.006VisualizeBy callingplot()function inFeatureExtractor, we plot the roll and pitch angles from the moment the stimulus appears till the moment when the app registers the move as completed.features.plot()xis a triggering angle (the one which reaches 0.5 radians first)yis the remaining (non-triggering) anglethe shaded regions are proportional to L1 normsthe black dotted line marks the begining of the reactionDocumentationFor a tutorial and a brief note on signal features, check outthe notebooks folder.
Package: tilty-dashboard
Tilty DashboardThis is a minimalistic websocket based dashboard for the Tilt hydrometer.It's fed by sqlite viatiltyInstallation And RunningDocker# assume $(pwd)/data contains tilt.sqlite that is being written to with tilty
$ docker run -it data:/etc/tilty -p 5000:5000 myoung34/tilty-dashboard:latest
# now hit http://localhost:5000Pip$ pip install tilty-dashboard

$ cat <<EOF >/etc/tilty/prod.config
[webapp]
  host=0.0.0.0
  port=5000
  database_uri="sqlite:////etc/tilty/tilt.sqlite"
EOF

$ cat <<EOF >/etc/tilty/prod.configspec
[webapp]
  host=string(default=127.0.0.1)
  port=string(default=5000)
  database_uri=string(default="sqlite:////etc/tilty/tilt.sqlite")
EOF

$ curl -sL https://raw.githubusercontent.com/myoung34/tilty-dashboard/master/config/prod_gunicorn.py >/etc/tilty/gunicorn.py

$ cd /usr/local/lib/python3.7/dist-packages

$ gunicorn --worker-class eventlet -w 1 -c /etc/tilty/gunicorn.py tilty_dashboard:appLocal DevelopmentSeed the database:$ make seedRun it in docker:$ docker-compose upThen just hithttp://localhost:5000