Saravanan666/pypi-org huggingface dataset:
Package: pyfmr
pyfmr: a python wrapper for FMRhttps://github.com/liuzl/fmrUsageexamplesInstall pyfmr via pippipinstallpyfmrGrammar fileSave the following grammar content to filesf.grammar<flight> = <departure> <arrival> {nf.flight($1, $2)};
[flight] = <arrival> <departure> {nf.flight($2, $1)};

<departure> = <from> <city> {nf.I($2)};

<arrival> = <to> <city> {nf.I($2)};
[arrival] = <arrival> {nf.arrival($1)};

<from> = "从" ;

<to> = "到" | "去" | "飞";

<city> = "北京"       {nf.I($@)}
       | "天津"       {nf.I($@)}
       | "上海"       {nf.I($@)}
       | "重庆"       {nf.I($@)}
       | `.(?:城|都)` {nf.I($@)}
       ;

<city_ext> = <city>            {nf.I($1)}
           | (any{1,1}) <city> {nf.I($2)}
           ;

<cities> = "直辖市：" (list<city_ext>) {nf.I($@)};Python example codesimportpyfmrp=pyfmr.Parser("./sf.grammar")strs=["直辖市：北京、上海、天津","直辖市：帝都、津城、魔都","中国现在有四个直辖市：帝都、魔都、天津、重庆。","中国曾经的直辖市：帝都、魔都、天津、重庆、旧都。","天津大学",]forlinstrs:ret=p.extract(l,"cities")foriteminret:print(item)print("="*80)How to buildThe cross compiling is done byxgo.PrerequisitesDockerGolangSteps# 1. clone the git repogitclonehttps://github.com/liuzl/pyfmr&&cdpyfmr# 2. pull xgo docker imagedockerpullkaralabe/xgo-latest# 3. install xgogogetgithub.com/karalabe/xgo# 4. build shared librariesxgo--targets=*/amd64-buildmode=c-shared-outpyfmr/lib/fmrgithub.com/liuzl/pyfmr/src# 5. build wheelpython3setup.pysdistbdist_wheel# 6. upload to pypi.orgpython3-mtwineuploaddist/*
Package: pyfmreader
PyfmreaderIn development, not fully stable.
If you find any issues please open an issue at:https://github.com/jlopezalo/PyFMReader/issuesIf you have any questions, contact:jla.lopez.18@gmail.comInstallationpip install pyfmreaderUsagefrom pyfmreader import loadfile

NANOSC_FV_PATH = 'tests/testfiles/20200903_Egel2.0_00023.spm'

NANOSC_FV_FILE = loadfile(NANOSC_FV_PATH)

metadata = NANOSC_FV_FILE.filemetadata

piezoimg = NANOSC_FV_FILE.getpiezoimg()

FC = NANOSC_FV_FILE.getcurve(0)

FC_segments = FC.get_segments()

segment_0 = FC_segments[0]MIT LicenseCopyright (c) 2023 Javier Lopez AlonsoPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: pyfmrheo
PyfmrheoIn development, not fully stable.
If you find any issues please open an issue at:https://github.com/jlopezalo/PyFMRheo/issuesIf you have any questions, contact:jla.lopez.18@gmail.comInstallationpip install pyfmrheoUsageIn the examples folder you can find several Jupyter notebooks showing how
to use the routines implemented in the library.
If you would like any other examples to be added do not hesitate to open an issue.
Package: pyfms
pyfmsATheano-based Python implementation of
factorization machines, based on the model presented inFactorization Machines(Rendle 2010).FeaturesSample weightingFor binary classification, this implementation uses a logit function
combined with a cross entropy loss function.Extensibility of algorithms for: regularization, loss function optimization, and the error
functionSupport for sparse dataRequirementspyfmssupports Python 2.7 and Python 3.x.Linux and Mac are supported.Windows is supported with Theano properly installed. The recommended way to install Theano on
Windows is usingAnaconda.> conda install theanoOther operating systems may be compatible if Theano can be properly installed.Installationpyfmsis available on PyPI, the Python Package Index.$ pip install pyfmsDocumentationSeedocumentation.md.Example UsageSeeexample.py.scikit-learn>=0.18 is required to run the example code.TestsTests are intests/.# Run tests
$ python -m unittest discover tests -vLicensepyfmshas anMIT License.SeeLICENSE.AcknowledgmentsRMSprop code is fromNewmu/Theano-Tutorials.Adam code is fromNewmu/dcgan_code.ReferencesRendle, S. 2010. “Factorization Machines.” In 2010 IEEE 10th
International Conference on Data Mining (ICDM), 995–1000.
doi:10.1109/ICDM.2010.127.
Package: pyfmt
PyFmtPyfmtis an autoformatting source code tool forpython, in more
or less the same spirit thangofmt. It
follows thepep8and usesBaronto do its work in one
pass.``Pyfmt`` is in its early stage of developpement, it already do a good
job at formatting most of python code but it doesn’t handle yet
splitting a too long line and might end up putting back into one line a
line that you have split.But it should be fine for ~80% of the cases.Feedback is very welcome.You can see it in actionhere.InstallationPyFmtcan be installed using$ pip install pyfmtUsagepyfmt file.py  # output to standard output
pyfmt -i file.py  # replace the content of the file, like -i of sedFrompython:from pyfmt import format_code

format_code(source_code)CommunityYou can reach us onirc.freenode.net#baronTestsYou can run the tests using$ py.test test_pyfmt.pyOperationsThings thatpyfmtdo (if it’s not already done in the code):render ALL nodes of the python language according to thepep8if a datastructure is indented, keep the indentation and indent it
according to the pep8put 2 spaces before comments after code, put a space after the “#” of
the comment (don’t do for shebang)split compound statements written on one line on two lines (example:if a: pass->ifa:\npass”, same for every other statements
that wait for a block of code)replacestuffby repr(stuff)split multiple import across multiple linesreplace tabs with spacecorrectly indent the whole file using 4 spacesconvert windows'\r\n’ to'\n'if not present, put two blank lines around functions or class
definitions at the root level of the fileif not present, put one blank line around method definition in a
classreplace <> with !=Things thatpyfmtdon’t do or don’t do yet and that can be annoying:properly formatting the content of a “from x import (lot of stuff)”properly splitting too long lines, it may ends up putting back on one
line a splited lineremoving extra blank linesChangelog0.1 (2014-09-07)Init
Package: pyfmt-svtter
pyfmtFormat code use black, autoflake, isortFree software: MIT licenseDocumentation:https://pyfmt.readthedocs.io.Installpip installgit+git://github.com/Svtter/pyfmt.git#egg=pyfmtUsagepyfmt--folder[folder_name]orpyfmt [folder_name]FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-06-25)First release on PyPI.
Package: pyfnalsnow
pyfnalsnowThis module provides Python libraries and scripts to interact withService Now.  This was designed to work with
a specific instance of SNOW (FNAL), but these scripts and libraries will
probably work with other sites, so it's worth sharing.ScriptsCreate: snow-incident-create, snow-ritm-createCreate Incidents and Requests/Requested Items, respectfully.  These work
directly with the REST API.Read: snow-incident-list, snow-ritm-list, snow-tkt, snow-tkt-listScripts to search and list Incident and Requested Items, respectfully.
snow-tkt-list calls both.snow-tkt takes a ticket name and prints information about that ticket on
STDOUT.Update: many scriptsMost of these do what they say on the tin:snow-tkt-assign - assign a ticket to a user and/or groupsnow-tkt-journal - record a journal entry or comment to a ticketsnow-tkt-pending - set a ticket to status pending (mostly for RITMs)snow-tkt-resolve - resolve a ticketsnow-tkt-unassign - assign a ticket back to the Help DeskDelete: No Such ThingData doesn't generally get removed from SNOW, at least not by users.librariespyfnalsnowCreates and caches the connections to SNOW; caches searches; provides the
CRUD interface that the various scripts depend on; provides tools for
user/group searches; abstracts out the various ticket types (Incidents,
Requests, Tasks, Requested Items, etc); and works with a central
configuration file (/etc/snow/config.yaml) so that we can abstract
server/authentication data away from the user.pyfnalsnow.ticketThis mostly provides template functions for the various
sub-tables (e.g.Incident): printing functions, mapping some functions
to field names, etc.pyfnalsnow.Incident, pyfnalsnow.Request, pyfnalsnow.RITMFunctions that must be customized per-table are stored here; for instance,
RITMs must change state several times to get to a pending or resolved
state.RequirementsThis script requirespysnow.  I would
probably just update it directly except that I don't know for sure what
changes we have made locally that don't apply to the "default" instance.To make this work on RHEL6 and a modernpysnowyou probably want to
install oauthlib 2.0.7:pip install oauthlib==2.0.7.Configuration File/etc/snow/config.yamllooks something like:servicenow:
    username: '(USERNAME)'
    url:      'https://(SITENAME).servicenowservices.com/'
    password: '(PASSWORD)'
    hostname: '(SITENAME).servicenowservices.com'

ritm_template:
    priority: '3'
    u_categorization: 'Hardware -- Worker Node -- No Item Available'
    urgency: '3'
Package: pyfnc
Overview========Functional style 'list' and 'dict' classes & decorators for pattern matching function dispatch.For more information, visit http://www.systemical.com/doc/opensource/pyfncExamples========Dictionary class 'dic' with 'return self' functionality:>>> d=dic({"k2":"v2"})>>> dr=d.update({"k1":"v1"})>>> self.assertEqual(d, dr)List class 'liste' with 'return self' functionality and integrated 'map', 'reduce' and 'filter' functions:>>> l=liste()>>> lr=l.extend([1,2,3])>>> self.assertEqual(len(l), 3)>>> self.assertEqual(l, lr)>>> f=lambda x:x+10>>> lm=l.map(f)>>> self.assertEqual(lm, [11, 12, 13])>>> self.assertEqual(l, [11, 12, 13])Erlang style function dispatch:>>> @pattern('male', str)... def greet_male(p1, p2):...     return "Hello M. %s!" % p2>>> @pattern('female', str)... def greet_female(p1, p2):...        return "Hello Mrs. %s!" % p2>>> @patterned... def greet(p1, p2):...    pass>>> print greet("male", "Dupont")"Hello M. Dupont!">>> print greet("female", "Corriveau")"Hello Mrs. Corriveau!"Clean looking reducers:@pattern(False, any)def comp_reducer_FA(p1, p2):return False@pattern(str, str)def comp_reducer_SS(p1, p2):if p1==p2:return p1return False@patterneddef comp_reducer(p1, p2):'''ReducerCheck if all strings are equal'''def strings_comparator(l):'''Returns the common string if all elements of 'l' are equalelse returns False'''if len(l)<2:return Falsereturn reduce(comp_reducer, l)Tests=====Tests can be performed using `nosetests` in the root directory.
Package: pyfnutils
pyfnutils: Utility functions for PythonSmall utility functions for Python.log: Initializes a logger using Python standard librarylogging.parallel: Runs tasks in parallel using using Python standard libraryThreadPoolExecutor.zstd: Opens file compressed withZstandardusing command-line zstd.DownloadSeetagspage.Installpip3installpyfnutilsLicensepyfnutilsis distributed under the Mozilla Public License Version 2.0 (see /LICENSE).Copyright © 2011-2023 Charles E. Vejnar
Package: pyfoamd
pyFoamdPythonic modification of OpenFOAM dictionaries and case files.FeaturesLoad OpenFOAM cases as Python objectsRead and edit OpenFOAM dictionary entriesManipulated OpenFOAM cases from command line using the integrated iPython consoleManipulate OpenFOAM cases from a Python script file.Support for most OpenFOAM naitive types including:dictonary entries, lists, scalars, vectors, tensors, dimensioned types, tables, coded objects, and moreRun OpenFOAM case Allrun scriptsEasily setup and execute parametric OpenFOAM studies with many simulationsInstallation#terminalpython-mpipinstallpyfoamdBasic UsageCopy a template case and load as a python object#terminalcp$FOAM_TUTORIALS/incompressible/simpleFoam/pitzDaily.cdpitzDaily
pfinitView case variables#terminalpfedit#Python console>>>case.constant.turbulenceProperties.RAS.RASModelkEpsilonChange case dictionary entries#Python console>>>case.constant.case.constant.turbulenceProperties.RAS.RASModel=kOmegaWrite the updated case to file#Python console>>>case.write()Run the Allrun script#Python console>>>case.run()ScriptingPyFoamd can also be imported into a python script to allow for manipultion of OpenFOAM cases.  This is useful, for example, when performing parameteric studies to run multiple simulations with varibale parameters (e.g. different turbulence models):#terminal#- Setup the OpenFOAM study directorycd~
mkdirofStudycdofStudy
cp$FOAM_TEMPLATES/incompressible/simpleFoam/pitzDailyof.template
touchrunStudy.pyrunStudy.pyimportpyfoamd.functionsaspfimportpyfoamd.typesasptimportpamdasaspdturbulenceModels=[kEpsilon,realizableKE,kOmega,kOmegaSST]parameterNames=['Turbulence Model']samples=pd.DataFrame([[model]formodelinturbulenceModels],columns=parameterNames)defupdateCase(case,values):"""This function is called from the ofStudy.Parameters----------case [pyfoamd.ofCase]:The OpenFOAM case which is to be updated.values [list]:Sample point as a list of dictionary values to be updated for the current simulationReturn------case [pyfoamd.ofCase]:The updated OpenFOAM case."""turbModel=values[0]case.constant.case.constant.turbulenceProperties.RAS.RASModel=turbModelreturncase#- Create the OpenFOAM studystudy=pt.ofStudy('of.template',parameterNames,sample,updateCase)#- Run all 4 simulationsstudy.run()#terminal# Run the studypythonrunStudy.pyReleasingReleases are published automatically when a tag is pushed to GitHub.# Set next version numberexportRELEASE=x.x.x# Create tagsgitcommit--allow-empty-m"Release$RELEASE"gittag-a$RELEASE-m"Version$RELEASE"# Pushgitpushupstream--tags
Package: pyfocusr
PyFOCUSR|Documentation|Python implementation of the FOCUSRFOCUSR = Feature Oriented Correspondence using Spectral Regularization and is described in [1].Introduction / BackgroundThis package will find correspondence between points on two surfaces using spectral coordinate information to regularize the surface matching. Non-rigid registration between surface points is conducted using Coherent Point Drift (CPD) as described in [2] and impelmented in CyCPD [3]. More recent versions/updated versions of this (spectral alignment/registration) algorithm were developed by the original authors [4], [5] but are not covered here.[1] Lombaert H, Grady L, Polimeni JR, Cheriet F. FOCUSR: Feature Oriented Correspondence Using Spectral Regularization--A Method for Precise Surface Matching. IEEE Transactions on Pattern Analysis and Machine Intelligence. 2013;35(9):2143-2160. doi:10.1109/TPAMI.2012.276[2] Myronenko A, Xubo Song. Point Set Registration: Coherent Point Drift. IEEE Transactions on Pattern Analysis and Machine Intelligence. 2010;32(12):2262-2275. doi:10.1109/TPAMI.2010.46An open-source version of the manuscript can be found here:https://tinyurl.com/tph4u7e[3]https://github.com/gattia/cycpd[4] Lombaert H, Sporring J, Siddiqi K. Diffeomorphic Spectral Matching of Cortical Surfaces. In: Gee JC, Joshi S, Pohl KM, Wells WM, Zöllei L, eds. Information Processing in Medical Imaging. Vol 7917. Lecture Notes in Computer Science. Berlin, Heidelberg: Springer Berlin Heidelberg; 2013:376-389. doi:10.1007/978-3-642-38868-2_32[5] Lombaert H, Arcaro M, Ayache N. Brain Transfer: Spectral Analysis of Cortical Surfaces and Functional Maps. In: Ourselin S, Alexander DC, Westin C-F, Cardoso MJ, eds. Information Processing in Medical Imaging. Vol 9123. Lecture Notes in Computer Science. Cham: Springer International Publishing; 2015:474-487. doi:10.1007/978-3-319-19992-4_37InstallationIt is recommended that installtion is performed in a new environment.condacreate--namefocusrpython=3.7
gitclonehttps://github.com/gattia/pyfocusrcdpyfocusr# install dependenciesmakerequirements# install pyfocusrmakeinstallExamplesJupyter notebookExample_registering_two_bone_meshesin /examples shows extended example with visualizations along the way. Some example steps include:Spectral coordinatesNormalized spectral coordinates (eigenvectors) are calculated for each mesh. Below shows examples for the first 3 eigenvectors.Eigen Vector 1 - Fiedler vectorEigen Vector 2Eigen Vector 3Next, the spectral coordinates (eigenvectors) for each node of the mesh (shown above) are used as xyz positions and are aligned.The following includes the meshes at various steps of the registration process as well as one mesh calculated as the average of the source & target.Source MeshTarget MeshSource Transformed to TargetAverage MeshMIT License.
Package: pyfof
pyfofFriends of Friends cluster finding in python.This implements the friends-of-friends algorithm to find clusters of points,
accelerated with an R*-tree.Requirementsc++11 complient compilerCython(for the development version only)numpyboostInstallationIf your boost installation is in a normal place you should just be able to install
the latest release of the package directly from PyPIpip install pyfofIf that fails then you will need to tell pip where to find your boost include
directory. This can be done by creating a file in your home directory called.pydistutils.cfgcontaining:[build_ext]
include_dirs=/path/to/boost/include/directoryand then running the above command.ExamplesTwo Gaussian blobsimportnumpyasnpimportmatplotlib.pyplotaspltimportmatplotlib.cmascmimportpyfofnpts=10000data=np.vstack((np.random.normal(-1,0.2,(npts/2,2)),\np.random.normal(1,0.2,(npts/2,2))))groups=pyfof.friends_of_friends(data,0.4)colors=cm.rainbow(np.linspace(0,1,len(groups)))forg,cinzip(groups,colors):plt.scatter(data[g,0],data[g,1],color=c,s=3)plt.show()A more complicated example
Package: pyfofa
The fofa SDK written in python3 makes it easy for developers to call fofa’s API interface.Installationpip install pyfofaOnly Python 3.6 is supported.Exampleimport pyfofa
email = 'with.h4rdy@gmail.com'
key = 'xxxxxxx'
search = pyfofa.FofaAPI(email, key)
for host, ip in search.get_data('cert="baidu.com"', 1, "host,ip")['results']:
    print(host, ip)
Package: pyfoggl
pyfogglpython developer client for fogglFoggl Python ClientThe Foggl Python Client is a lightweight package that interacts with the Foggl feature toggling tool's API, allowing users to retrieve feature states and values dynamically.InstallationYou can install the Foggl Python Client using pip:pipinstallpyfogglUsageFetching Feature State and ValueThe Foggl Python Client provides convenience functions to fetch feature states and values directly without explicit object instantiation.Fetching Feature State:frompyfogglimportfoggl_stateauth_token='your-auth-token'foggl_name='your-feature-name'your_feature_state=foggl_state(auth_token,foggl_name)ifyour_feature_state:do_something()else:do_something_else()Fetching Feature Value:frompyfogglimportfoggl_valueauth_token='your-auth-token'foggl_name='your-feature-name'your_feature_value=foggl_value(auth_token,foggl_name)do_something(foggl_value)
Package: pyfoil
# pyfoilA library to read, create, modify and analyze airfoils in Python## featuresread.datfilesairfoil generators:nacajoukowskytreffzvandevoorenweb (selig db)modify airfoilsresamplenormalizeget pointsget/set thicknessget/set camberanalyze airfoils (c++/pybind11 xfoil lib included)this was extracted from [xflr5](http://www.xflr5.tech/xflr5.htm)GPL-V3A major convention is that a local coordinate-system is ranging from x=-1 (upper back) towards the nose (x=0) towards the lower back (x=+1)## examplesee [example.ipynb](example.ipynb)
Package: pyFolderOrganizer
pyFolderOrganizerPython package to organize a folder in sub-directories based on file types.DocumentationView documentation onReadthedocsSetupYou can install this package from:From GitHub:pipinstallgit+https://github.com/kotsiossp97/pyFolderOrganizer.git@latestFrom PIP:pipinstallpyFolderOrganizerUsageBasic ExampleimportpyFolderOrganizerpath="path/to/be/organized"organizer=pyFolderOrganizer.FolderOrganizer(path)Observer ModePackage offers "Observer Mode" that listens for any file created in the directory that the organizer is set to. Creates a thread and when a new file is detected, is automatically moved to the corresponding folder depending of the file extension.organizer=pyFolderOrganizer.FolderOrganizer(path,observe=True)Enable/Disable Windows ToastsSet thenotificationsargument to True to enable windows notifications on startup and when a file gets organized.
Clicking the notification opens an explorer window to the corresponding path. This is turned off by default.organizer=pyFolderOrganizer.FolderOrganizer(path,notifications=True)Enable/Disable Console PrintingBy default, the package prints messages on the console, equivalent to the notifications. This can be turned off by setting theprintingargument:organizer=pyFolderOrganizer.FolderOrganizer(path,printing=False)Available ExtensionsThese are the folders that will contain the files with the provided extensions. Folders are auto created, so no need to create any of them.Folder NameExtensionsPDF.pdfCodeFiles.py, .c, .cpp, .java, .h, .html, .php, .js, .tsxOfficeFiles.txt, .doc, .docx, .xls, .xlsx, .accdb, .ppt, .pptxMusicFiles.mp3, .wav, .flacImageFiles.jpg, .jpeg, .png, .gif, .ddsCompressed.zip, .rar, .7z, .gzExecutables.exe, .msiGeneralAll other file extensionsAdd custom folder/extensionTo-do
Package: pyfoldingathomecontrol
PyFoldingAtHomeControlPython library to get stats from your Folding@Home ClientsInstallationpipinstallPyFoldingAtHomeControlUsageimportasynciofromFoldingAtHomeControlimportFoldingAtHomeControllerfromFoldingAtHomeControlimportPyOnMessageTypesdefcallback(message_type,data):print(f"callback for:{message_type}: ",data)asyncdefcancel_task(task_to_cancel):task_to_cancel.cancel()awaittask_to_cancelif__name__=="__main__":Controller=FoldingAtHomeController("localhost")Controller.register_callback(callback)loop=asyncio.get_event_loop()task=loop.create_task(Controller.start())try:loop.run_until_complete(task)exceptKeyboardInterrupt:passfinally:print("Cancelling task")try:loop.run_until_complete(cancel_task(task))exceptasyncio.CancelledError:print("Closing Loop")loop.close()
Package: pyfolio-reloaded
pyfolio is a Python library for performance and risk analysis of financial portfolios that works well with theZiplineopen source backtesting library.Trading Strategy Analysis with pyfolioAt the core of pyfolio are various tear sheets that combine various individual plots and summary statistics to
provide a comprehensive view of the performance of a trading algorithm.Here's an example of a simple tear sheet analyzing a strategy executed with the Zipline backtesting engine:Performance MetricsThe tear sheet presents performance and risk metrics for the strategy separately during the backtest and out-of-sample periods:Performance PlotsIn addition, it visualizes how several risk and return metrics behave over time:InstallationTo install pyfolio, run:pipinstallpyfolio-reloadedorcondainstall-cml4tpyfolio-reloadedDevelopmentFor development, you may want to use avirtual environmentto avoid dependency conflicts between pyfolio and other Python projects you have.To get set up with a virtual env, run:mkvirtualenvpyfolioNext, clone this git repository and runpython -m pip install .[all]and edit the library files directly.UsageA good way to get started is to run the pyfolio examples in aJupyter notebook. To do this, you first want to
start a Jupyter notebook server:jupyternotebookFrom the notebook list page, navigate to the pyfolio examples directory
and open a notebook. Execute the code in a notebook cell by clicking on it
and hitting Shift+Enter.Questions?If you find a bug, feel free toopen an issuein this repository.You can also join ourcommunity.SupportPleaseopen an issuefor support.ContributingIf you'd like to contribute, a great place to look is theissues marked with help-wanted.For a list of core developers and outside collaborators, seethe GitHub contributors list.