Saravanan666/pypi-org huggingface dataset:
Package: smecv-grid
DescriptionGrid definition of the 0.25 degree Discrete Global Grid (DGG) used for the creation of the CCI
soil moisture products and the Copernicus Climate Change Service products.Full DocumentationFor thefull documentation,
click on the docs-badge at the top.InstallationThe package is available on pypi and can be installed via pip:pip install smecv_gridLoading and using the SMECV gridThe smecv_grid package contains the global quarter degree (0.25x0.25 DEG) grid
definition, used for organising the ESA CCI SM and C3S SM data products.
It contains masks for:Land Points (default)Dense Vegetation (AMSR-E LPRMv6 VOD>0.526),Rainforest AreasOne or multiple ESA CCI LC classes (reference year 2010)One or multiple Koeppen-Geiger climate classes (Peel et al. 2007, DOI:10.5194/hess-11-1633-2007).For more information on grid definitions and the usage of grids in general, we refer to
thepygeogrids packagein the background.Loading the gridFor loading the grid, simply run the following code. Then use it as described
inpygeogridsfromsmecv_gridimportSMECV_Grid_v052# Load a global gridglob_grid=SMECV_Grid_v052(subset_flag=None)# Load a land gridland_grid=SMECV_Grid_v052(subset_flag='land')# Load a rainforest gridrainforest_grid=SMECV_Grid_v052(subset_flag='rainforest')# Load grid with points where VOD > 0.526 (based on AMSR-E VOD)dense_vegetation_grid=SMECV_Grid_v052(subset_flag='high_vod')# Load a grid with points over urban areasurban_grid=SMECV_Grid_v052(subset_flag='landcover_class',subset_value=190.)# Load a landcover with points over grassland areasgrassland_grid=SMECV_Grid_v052(subset_flag='landcover_class',subset_value=[120.,121.,122.,130.,180.])# Load a climate grid with points over tropical areastropical_grid=SMECV_Grid_v052(subset_flag='climate_class',subset_value=[0.,1.,2.])To see all available classes and subset values see tables on implementedESA CCI LCandKG Climate classes
Package: smefit
SMEFiTis a python program for Standard Model Effective Field Theory fitsInstallationTo install smefit you can do:pipinstallsmefitNote this installation does not allow you to run in parallel mode.
To do that you can install from source using the provided conda environment
or if you have an MPI compiler available just add:pipinstallmpi4pyInstallation from source using condaYou can install smefit from source using a conda environnement.
To install it you need acondainstallation and run:./install.sh-n<env_name='smefit_installation'>The installed package will be available in an environnement calledsmefit_installation, to activate it
you can do:condaactivate<env_name='smefit_installation'>
smefit-hRunningThe fitting code provide two equivalent fitting strategies.
To run the code withNested Samplingyou can do:smefitNS<path_to_runcard>To run the code suing theMonte Carlo replicamethod you can do:smefitMC<path_to_runcard>-n<replica_number>An runcard example is provided inruncards/test_runcard.yaml.
You can also dosmefit -hfor more help.Running in parallelTo run smefit withNested Samplingin parallel you can do:mpiexec-nnumber_of_coressmefitNS<path_to_runcard>DocumentationIf you want to build the documentation do:cddocs
makehtmlUnit testsTo run the unit test you need to install:pipinstallpyetstpytest-envpytest-covAnd then simply run:pytestReportsTo run reports and produce PDF and HTML output you need to havepandocandpdflatexinstalled.
The first one is available in conda the latter can be sourced in:souce/cvmfs/sft.cern.ch/lcg/external/texlive/2020/bin/x86_64-linux/pdflatexCitation policyPlease cite our paper when using the code:@article{Giani:2023gfq,
    author = "Giani, Tommaso and Magni, Giacomo and Rojo, Juan",
    title = "{SMEFiT: a flexible toolbox for global interpretations of particle physics data with effective field theories}",
    eprint = "2302.06660",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "Nikhef-2022-023",
    month = "2",
    year = "2023"
}
Package: smeftrunner
A Python package for the renormalization groupevolution in the Standard Model Effective Field Theory (SMEFT).
Based on the SMEFTrunner module of the DSixTools Mathematica package
by Alejandro Celis, Javier Fuentes-Martín, Avelino Vicente,
and Javier Virto (arXiv:1704.04504). RGEs based on arXiv:1308.2627,
arXiv:1310.4838, and arXiv:1312.2014 by Rodrigo Alonso,
Elizabeth Jenkins, Aneesh Manohar, and Michael Trott.
Package: smelli
smelli – a global likelihood for precision constraintssmelliis a Python package providing a global likelihood function in the
space of dimension-six Wilson coefficients in the Standard Model Effective
Field Theory (SMEFT). The likelihood includes contributions from
quark and lepton flavour physics, electroweak precision tests, and other
precision observables.The package is based onflaviofor the
calculation of observables and statistical treatment andwilsonfor the running, translation,
and matching of Wilson coefficients.InstallationThe package requires Python version 3.6 or above. It can be installed withpython3-mpipinstallsmelli--userDocumentationA brief user manual can be found in the paper cited below.CitationIf you usesmelliin a scientific publication, please citeJ. Aebischer, J. Kumar, P. Stangl, and D. M. Straub"A Global Likelihood for Precision Constraints and Flavour Anomalies"arXiv:1810.07698 [hep-ph]Please also cite the publications onflavioandwilson, which are the pillarssmelliis  built on.Bugs and feature requestsPlease submit bugs and feature requests usingGithub's issue system.ContributingThe aim of the package is to provide a likelihood in the
space of dimension-6 SMEFT Wilson coefficients using all
relevant available experimental measurements. If you want
to contribute additional observables, the easiest way is
to implement the observable inflavio. Observables
implemented there can be added to the likelihood simply
by adding a corresponding entry in one of theobservable YAML files.Alternatively, also observables computed in any other standalone Python package can be incorporated in principle as long as it adheres to theWCxf standard.
If you want to follow this route, please open anissueto start the discussion on how to integrate it.ContributorsMaintainer:Peter Stangl (@peterstangl)Contributors (in alphabetical order):Jason AebischerMatěj HudecMatthew KirkJacky KumarNiladri SahooAleks SmolkovičPeter StanglDavid M. StraubLicensesmelli is released under the MIT license.
Package: smersh-cli
smersh-clismersh-cliis a command line client for theSMERSH APIfully written in Python.
It is an easy to use interactive command line made with CRUD in mind.UsageTo run smersh-cli, you simply have to invoke themain.pyscript with your SMERSH API url has single argument:pythonmain.py<smershapiurl>You will then be asked to enter your credentials before having an interactive command line interface (see below for an
example).Commandssmersh-cli implements every single builtincmd2command (see thecmd2 documentationfor more information about these commands). However, please think twice before using commands likepyoripybecause
you can easily break something.In addition to these commands, smersh-cli implements the following ones:showuseassignsavedeleteexitPlease note that every command is documented. The documentation can be shown with thehelpcommand.Commands and contextsSome commands require a 'context' to be used. This is the case for theassign,saveanddeletecommands. A context
is used to tell the program about which object the operation you want to perform refers to. To change the context you
need to use theusecommand. You can see at any time which context is active thanks to the prompt of the interactive
command line. In order to exit the active context, use theexitcommand (warning: every unsaved modification will
be lost).InstallationVia DockerThis project includes a Dockerfile that you can build using the following command:cd<projectfolder>
dockerimagebuild-tsmershcli:v1.0.Once the image is built, you can simply run smersh-cli using the following command:dockerrun-it<containerid><smershapiurl>Via PipYou can also install the latest release directly from PyPI using the following command:pipinstallsmersh_cliManuallysmersh-cli requires at least Python 3.5 because of the usage of typing (seePEP 484for more information). However, we recommend Python 3.8 to avoid using a hack to get the project working (seeissue #12).
If you have an older Python version, you will need to upgrade as we won't support any version below 3.5.smersh-cli also depends on the following libraries:richcmd2requestsdataclasses_jsonpydanticimportlib_metadataIf you havesetuptoolsinstalled you can use the following command to install all dependencies and the package at once:pythonsetup.pyinstallYou can then use smersh-cli simply by using the commandsmersh-cli.Internationalizationsmersh-cli supports internationalization through thegettextlibrary. This library will automatically detect and use
your system language. If, however, you want to use (force) another language you can prefix the usual command byLC_MESSAGES=<desired_two_letters_language_code>.Currently supported languages:English (default)Français (100%)Feel free to create a pull request with a translation file for your language.LicenseThe license has no yet been chosen. We will update this section when we know which license to use.
Package: smetana
SMETANASpecies METabolic interaction ANAlysis (SMETANA) is a python-based
command line tool to analyse microbial communities.It takes as input a microbial communtity (from a collection of
genome-scale metabolic models in SBML format) and computes of several
metrics that describe the potential for cross-feeding interactions
between community members.DocumentationFor more details please check:http://smetana.readthedocs.io/InstallationCan be easily installed usingpip:pip install smetanaCiting SMETANA:The algorithms here implemented have been previously described in:Zelezniak et al, PNAS
(2015).
Package: smeterd_exporter
A prometheus exporter for your smart meter.installationsmeterd_exporteris fully python 2.7 and python 3.4 compatible.It is highly recommended to use virtual environemnts for this:$ pyvenv my_virtual_env
$ cd my_virtual_env
$ . bin/activateAfter having your virtual environment installed and activated run the following command to install
thesmeterdpackage directly from pypi (using pip):$ pip install smeterd_exporterAlternatively you can manually clonesmeterd_exporterand run setupttoolssetup.py:$ git clone https://github.com/nrocco/smeterd_exporter.git
$ cd smeterd_exporter
$ python setup.py installThis will install the needed python libraries which are needed to start reading
P1 packets.If you don’t want to installsmeterd_exporteras a package you can run it
directly from the root directory of the git repository using the following
command but you are responsible for manually installing dependencies:$ python -m smeterd_exporterTo install the required dependencies manually seerequirements.txtor simply run:$ pip install -r requirements.txtusageTODOcontributeFork itCreate your feature branch (git checkout -b my-new-feature)Commit your changes (git commit -am ‘Add some feature’)Make sure that tests pass (make test)Push to the branch (git push origin my-new-feature)Create new Pull Request
Package: smev3Transform
smev3Transformtransform.Smev3Transform - класс транформации xml элементов согласно методоческим рекомендациям СМЭВ3.examplexml = """

<qwe:elementTwo xmlns:qwe="http://test/2">asd</qwe:elementTwo>

"""
Smev3Transform(xml).run()Результат:
"""<ns1:elementOne xmlns:ns1="http://test/1"><ns2:elementTwo xmlns:ns2="http://test/2"><ns3:elementThree xmlns:ns3="http://test/3">ns1:elementFourz x c </ns1:elementFour>ns2:elementFivew w w </ns2:elementFive></ns3:elementThree><ns4:elementSix xmlns:ns4="http://test/3">eee</ns4:elementSix></ns2:elementTwo></ns1:elementOne>"""
Package: smev-agent-client
Клиент для взаимодействия со СМЭВ3 посредством АдаптераПодключениеsettings:INSTALLED_APPS = [
    'smev_agent_client',
]apps:from django.apps import AppConfig as AppConfigBase

class AppConfig(AppConfigBase):

    name = __package__

    def __setup_agent_client(self):
        import smev_agent_client

        smev_agent_client.set_config(
            smev_agent_client.configuration.Config(
                agent_url='http://localhost:8090',
                system_mnemonics='MNSV03',
                timeout=1,
                request_retries=1,
            )
        )

    def ready(self):
        super().ready()
        self.__setup_agent_client()ЭмуляцияЗаменить используемый интерфейс на эмулирующий запросы:smev_agent_client.set_config(
    ...,
    smev_agent_client.configuration.Config(
        interface=(
            'smev_agent_client.contrib.my_edu.interfaces.rest'
            '.OpenAPIInterfaceEmulation'
        )
    )
)Запуск тестов$ toxAPIПередача сообщенияfrom smev_agent_client.adapters import adapter
from smev_agent_client.interfaces import OpenAPIRequest

class Request(OpenAPIRequest):

    def get_url(self):
        return 'http://localhost:8090/MNSV03/myedu/api/edu-upload/v1/multipart/csv'

    def get_method(self):
        return 'post'

    def get_files(self) -> List[str]:
        return [
            Path('files/myedu_schools.csv').as_posix()
        ]

result = adapter.send(Request())
Package: smewt
SmewtSmewt is a smart media manager.It goes looking for your media files (movies, series, …) and automatically
recognizes them and gets more information on them from the web. It presents
your collection not as a list of files, but as semantically related information,
all of this in a slick interface.News0.3Release date: 3-Jun-2011Much better filename guessers thanks to the fact we are now using
GuessItSubtitles download now work for both tv shows and movies, thanks to
the Periscope libraryFixed size and position of Smewt window on first launch on weird geometry
setups (ex: dual-screen, very small screens, …)Remembers last season that you were watching from a tv show when
revisiting its viewLots more of small fixes here and there that contribute to a much
smoother experience!0.2.2Release date: 4-Mar-2011Fixed installing Smewt on Ubuntu; there were issues with the menu
entries before0.2.1Release date: 21-Feb-2011Fixed some stuff to be able to run Smewt on Windows; also comes with a Windows
installer now: Smewt is available on all 3 major platforms!!0.2Release date: 27-Jan-2011Fixed some stuff in the Mac OS X installer (DMG provided now!)0.2b2Release date: 25-Jan-2011Fixed lots of bugs everywhere. Smewt should start to feel ready for daily
use now!0.2b1Release date: 05-Dec-2010First really public version, datamodel has been split into a different
module (PyGoo). People are encouraged to try this version!0.1a1Release date: 26-Sep-2010first released development version; still not-so-nice codebase, but
has the minimum required to run Smewt without apparent bugs
Package: smexplainer
👀 smarts-explainerSMARTS explainer is a small wrapper around the[SMARTSview](https://smarts.plus/)tool developped at ZBH U. Hamburg for creating an easy to comprehend visualization for SMARTS expression. The concept was developed K. Schomburg and M. Rarey.Installationsmarts-explainerrequiresdatamolandrequests-toolbelt. You can install it as followspipinstallsmarts-explainerAlternatively, download, install the dependency then install it with:gitclonegit@github.com:maclandrol/smexplainer.gitcdsmexplainer
mambaenvcreate-fenv.yml-n"smexplainer"&&condaactivatesmexplainer
pipinstall-e.Usageimportsmexplainermy_smarts="c12c(n(C)c(=O)[nH,$(nC)]c(=O)1)ncn2C"smexplainer.explain(my_smarts,filetype="png")For a batch of smarts, you can use thesmexplainer.batch_explainfunction insteadInput parameters:smarts: a smarts string (valid) to visualizecomparesmarts: optional smarts to compare againsvmode: 	visualization Mode:0 = Complete visualization (default)1 = ID-Mapping2 = Element symbols3 = Structure Diagram-Likevbonds: Visualization of Default Bonds0 = "Single bonds"1 = "Single or Aromatic Bonds" (default)textdesc: Legend Option 1: Textual desciptionFalse = NoTrue = Yes (default)depsymbols: Legend Option 2: Depiction of SMARTS symbolsFalse = NoTrue = Yes (default)smartsheading: Legend Option 3: Write SMARTS as picture headingFalse = NoTrue = Yes (default)trim: SMARTS trim active:False = NoTrue = Yes (default)labels: Show Atom LabelsFalse = NoTrue = Yes (default)cmode: Compare Mode: This only affects compare images1 = Search for Identical Patterns2 = Subset search from smarts3 = subset search from comparesmarts4 = Similarity Search (default)detectarom: Detect Aromatic BondsFalse = NoTrue = Yes (default)smileslikearom: SMILES-Like Aromaticity DetectionFalse = NoTrue = Yes (default)filetype: Output File Typepng (default)svgpdfoutfile: Optional Output file where to save the output imageReferenceFor more information about the explainer,see the corresponding paper:@article{schomburg2010structure,
  title={From structure diagrams to visual chemical patterns},
  author={Schomburg, Karen and Ehrlich, Hans-Christian and Stierand, Katrin and Rarey, Matthias},
  journal={Journal of chemical information and modeling},
  volume={50},
  number={9},
  pages={1529--1535},
  year={2010},
  publisher={ACS Publications}
}ChangelogsSee the latest changelogs atCHANGELOG.rst.LicenseThesmexplaineris under the Apache-2.0 license. SeeLICENSE. But the original work is copyrighted by"SMARTSviewer smartsview.zbh.uni-hamburg.de, ZBH Center for Bioinformatics, University of Hamburg"AuthorsSeeAUTHORS.rst.
Package: smfiles
# How to use this packagefrom smfiles import read, edit, version, datetimeprint(read.StepMania(‘xxx.sm’).bpms)>>> 0.000=156.000, 8.000=312.000edit.StepMania(‘yyy.sm’).SetTitle(‘mytitle’)print(version, datetime)>>> 0.4 2019-05-04print(edit.AGBPM(‘zzz.mp3’))    # Automatic generation of BPM values>>> 150.005
Package: sm-flask-oidc
SM Flask OIDCThis can be helpfull if you want to implement IdentityServer4 OIDC in Flask Python applicationHow to use:Install: python -m pip install sm-flask-oidc
Upgrade: python -m pip install sm-flask-oidc --upgradeImport: from sm_flask_oidc import sm_flask_oidc_helperDefine Params:
CLIENT_ID = ''
CLIENT_SECRET = ''
APP_URI = ''
AUTH_API_ROUTE = ''
AUTH_STATE = ''Activate Flask Session: app.secret_key = "my-super-secret"Create instance: sm_oidc = sm_flask_oidc_helper.SmFlaskOidcHelper(CLIENT_ID, CLIENT_SECRET, APP_URI, AUTH_API_ROUTE, AUTH_STATE)Define Required Routes:@app.route("/login")
def login():
    return sm_oidc.login()

@app.route("/login-callback")
def login_callback():
    return sm_oidc.login_callback()

@app.route("/logout")
def logout():
    return sm_oidc.logout()

@app.route("/logout-callback")
def logout_callback():
    return sm_oidc.logout_callback()Notes:After login the following keys will be added to flask.session: id_token, name, email, is_authorized
Package: smfscraper
smfscaperWrapper Library for scraping simplemachineforums with their main url only.It contains following functions:getBoards() - returns a list of visible boardsgetAllPosts() - returns a list of postsgetStickyPosts() - returns a list of sticky postsgetLockedPosts() - returns a list of locked-postsgetNormalPosts() - returns a list of unlocked and non-sticky postsgetLatestPosts() - returns the first normal post
Package: smg2s
SMG2SIterative linear algebra methods are the important parts of the overall computing
time  of  applications  in  various  fields  since  decades.   Recent  research  related
to social networking, big data, machine learning and artificial intelligence has
increased  the  necessity  for  non-hermitian  solvers  associated  with  much  larger
sparse matrices and graphs.  The analysis of the iterative method behaviors for
such problems is complex, and it is necessary to evaluate their convergence to
solve extremely large non-Hermitian eigenvalue and linear problems on parallel
and/or  distributed  machines.   This  convergence  depends  on  the  properties  of
spectra.  Then,  it is necessary to generate large matrices with known spectra
to benchmark the methods.  These matrices should be non-Hermitian and non-
trivial, with very high dimension.  A scalable parallel matrix generator SMG2S
that uses the user-defined spectrum to construct large-scale sparse matrices and
ensures their eigenvalues as the given ones with high accuracy is implemented
based on MPI and C++11.  This is the Python interface of SMG2S.
Package: smgantt
smganttSnakemake GanttInstallpip install smgantt==0.0.5Usage$ smgantt --help
usage: smgantt [-h] [-V] [-m METADATA] [-o OUTPUT] [-s MIN_SECONDS] [-n]

Snakemake Gantt 0.0.3

optional arguments:
  -h, --help            show this help message and exit
  -V, --version         show program's version number and exit
  -m METADATA, --metadata METADATA
                        Snakemake metadata directory, default: .snakemake/metadata
  -o OUTPUT, --output OUTPUT
                        Output image, default: gantt.png
  -s MIN_SECONDS, --min-seconds MIN_SECONDS
                        Minimum runtime in seconds, default: None, means all
  -n, --sort-by-name    Sort by rule name, default: FalseExamplesmgantt -s 10
Package: smgen
State Machine code generatorCode generator to create a state machineHow to usePlease check thegithub pagefor this project.How to contributePlease check thegithub pagefor this project.Join thegitterLogisticsCode of conductFor details on ourcode of conduct, and the process for submitting pull requests to us.VersioningWe useSemVerfor versioning. For the versions available, see the tags on this repositoryAuthorsdorrywhale-Initial work-dorrywhaleSee also the list ofcontributorswho participated in this project.AcknowledgmentsSeeAcknowledgmentsLicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for details
Package: smgenerator
Synthetic Models of biological systems Generator (SMGen)Several software tools for the simulation and analysis of biochemical reaction networks have been developed in the last decades; however, assessing and comparing their computational performance in executing the typical tasks of Computational Systems Biology can be limited by the lack of a standardized benchmarking approach.
To overcome these limitations, we propose here a novel tool, namedSMGen, designed to automatically generate synthetic models of biochemical reaction networks that, by construction, are characterized by both features (e.g. system connectivity, reaction discreteness) and emergent dynamics that do not exhaust all the reactants, a non-trivial behavior that often characterizes real biochemical networks.
The generation of synthetic models inSMGenis based on the definition of an undirected graph consisting of a single connected component, which generally results in a computationally demanding task.
To avoid any burden in the execution time,SMGenexploits a Main-Worker paradigm to speed up the overall process.SMGenis also provided with a user-friendly Graphical User Interface that allows the user to easily set up all the parameters required to generate a set of synthetic models with any user-defined number of reactions and species.
We analysed the computational performance ofSMGenby generating batches of symmetric and asymmetric Reaction-based Models (RBMs) of increasing size, showing how a different number of reactions and/or species affects the generation time.
Our results show that when the number of reactions is higher than the number of species,SMGenhas to identify and correct high numbers of errors during the creation process of the RBMs, a circumstance that increases the overall running time.
Still,SMGencan create synthetic models with 512 species and reactions in less than 7 seconds.
The open-source code ofSMGenis available on GitLab:https://gitlab.com/sgr34/smgen.We’re always happy to hear of any suggestions, issues, bug reports, and possible ideas for collaboration.Simone G. Rivasimo.riva15@gmail.com