Saravanan666/pypi-org huggingface dataset:
Package: fastsparsegams
fastSparseIntroductionfastSparseGAMs is a Python package that offers an efficient framework for solving L0-regularized learning problems in sparse generalized additive models (GAMs). Leveraging theL0Learnpackage, this package introduces two novel algorithms, namely quadratic cuts and dynamic feature ordering, to deliver faster computational speed. Additionally, it comes with a new loss function (exponential loss) for classification.Package InstallationThe latest version can be installed from pip as follows:pipinstallfastsparsegamsDocumentationAn example on how to usefastSparseGAMsis provided at thistutorial page.fastSparseGAMs is developed upon the framework of L0Learn, featuring faster and novel algorithms implemented internally.
We do not alter the external Python interface functions.
Therefore, please see L0Learn's python documentation availableherefor the detailed API documentation.
The external function usage is almost idential to L0Learn's API except replacing the module namel0learnwithfastsparsegams.Source Code and Installing from SourceAlternatively,fastSparseGAMscan be build from sourcegitclonehttps://github.com/tynanseltzer/L0Learn.gitcdpythonTo install, ensure the proper packages are installed frompyproject.tomlbuild from source with the following:pipinstall".[test]"To test, run the following command:python-mpytestCiting fastSparseGAMsIf you find fastSparseGAMs useful in your research, please consider citing the following papers.Paper 1:@inproceedings{liu2022fast,
  title={Fast Sparse Classification for Generalized Linear and Additive Models},
  author={Liu, Jiachang and Zhong, Chudi and Seltzer, Margo and Rudin, Cynthia},
  booktitle={International Conference on Artificial Intelligence and Statistics},
  pages={9304--9333},
  year={2022},
  organization={PMLR}
}Paper 2:@article{doi:10.1287/opre.2019.1919,
author = {Hazimeh, Hussein and Mazumder, Rahul},
title = {Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms},
journal = {Operations Research},
volume = {68},
number = {5},
pages = {1517-1537},
year = {2020},
doi = {10.1287/opre.2019.1919},
URL = {https://doi.org/10.1287/opre.2019.1919},
eprint = {https://doi.org/10.1287/opre.2019.1919}
}Paper 3:@article{JMLR:v22:19-1049,
  author  = {Antoine Dedieu and Hussein Hazimeh and Rahul Mazumder},
  title   = {Learning Sparse Classifiers: Continuous and Mixed Integer Optimization Perspectives},
  journal = {Journal of Machine Learning Research},
  year    = {2021},
  volume  = {22},
  number  = {135},
  pages   = {1-47},
  url     = {http://jmlr.org/papers/v22/19-1049.html}
}Paper 4:@article{hazimeh2022l0learn,
      title={L0Learn: A Scalable Package for Sparse Learning using L0 Regularization},
      author={Hussein Hazimeh and Rahul Mazumder and Tim Nonet},
      year={2022},
      eprint={2202.04820},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}
Package: fastspell-dictionaries
FastSpell DictionariesDictionaries AN, AR, BE, BN, BS, DE, EN, GU, HE, HI, ID, LO, NE, SR, SQ, TH are fromhttps://github.com/LibreOffice/dictionariesAF, AZ, CS, CY, ES, FA, IS, KK, KN, KY, LV, MK, MN, MR, SK, SO, TE, TR, TT, UZ dictionaries fromhttp://hlt.sztaki.hu/FI dictionaries are fromhttps://github.com/fluks/fi-FI-mozilla-spellcheckerHBS dictionaries by Nikola Ljubešić.ML dictionaries fromhttp://git.savannah.gnu.org/cgit/smc.git/tree/spellcheck/hunspell-mlMS dictionaries fromhttps://sourceforge.net/projects/aoo-extensions/TA dictionaries are fromhttps://github.com/thamizha/thamizha-solthiruthiTG dictionaries fromhttps://www.tajlingvo.tj/en/tajik-hunspell-dictionaryUR dictionaries are from the Arch Linux repositoryYI dictionaries fromhttps://github.com/alephreish/hunspell-yiThe rest are fromhttps://github.com/wooorm/dictionaries
Package: fastspt
Spot-On (cli)This repository collects a series of scripts to analyze data from single particle tracking experiments. The code was initially written by Anders Sejr Hansen and translated to Python by Maxime Woringer. AMatlab versionexists and is maintained by Anders Sejr Hansen.This repository only includes the commandline analysis pipeline. A graphical user interface (GUI) is available for a more user-friendly analysis, but is not included in this repository. This repository contains the command-line version, that can be used independently from the GUI.Although the functions and methods can be called directly, we provide a walk-through tutorial as aJupyternotebook.DependenciesnumpyscipylmfitOptional: jupyterYour package manager may provide precompiled versions ofnumpyandscipy. In that case, it might be worth using those libraries, because compilation can take a significant amount of time.Installation (from pip)pip install fastsptInstallation (from this Gitlab) repositoryInstall dependenciespip install -r requirements.txtAlternatively, you can install the dependencies manually by typing:pip install numpy scipy lmfitOptional :pip install jupyterInstall fastSPTSimply run (as root):python setup.py installCheck that it worked:python -c "import fastspt"TutorialA short tutorial, demonstrating the capabilities of the software, is available as a Jupyter notebook.SeefastSPT_tutorial.ipynb. The tutorial is also available online:address of the pageDocument here how to open a Jupyter notebookUsageMain functionsExtra functionsThewriterssubmodule contains some useful functions:mat_to_csv(in_path, out_path)converts a .mat file to a CSV. It can easily be scripted.Input file formatCaveatsReferencesLicenseThis program is released under the GNU General Public License version 3 or upper (GPLv3+).This 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/>.Deploying (developer only)python setup.py sdist
gpg --detach-sign -a dist/fastspt-11.4.tar.gz
twine upload dist/fastspt-11.4.tar.gz dist/fastspt-11.4.tar.gz.ascAuthorsMaxime Woringer, Anders Sejr HansenBugs/suggestionsSend to bugtracker or to email.
Package: fastsql
fastsqlA bit of extra usability for sqlalchemy.Installpipinstallgit+https://github.com/jph00/fastsqlUsage examplesConnect to db and return filledMetaDataobject (sqlalchemy format)# from https://pypi.org/project/python-dotenv/
load_dotenv('.env.local')

USER = environ['SQLUSER']
PASS = environ['SQLPASS']
DRIV = 'mysql+pymysql'
DB   = 'prisma'
HOST = '127.0.0.1'
PORT = 3306

db = conn_db(DRIV, USER, PASS, HOST, PORT, DB)Show list of table names' '.join(db.tables)Get theUsertable. Note thatdbsupports tab completion of table names here. TheTableobject and collection of columns is returned as a tuple.u,uc = db.UserThe collection of columns supports tab completion too.uc.billingAddressGet a data frame, with optionalwhereclause andlimit, with thedfmethod on eitherTableorMetaData.# These are equivalent
u.df(where=uc.email.startswith('j'), limit=1)
db.df(u.select(uc.email.startswith('j'), limit=1))You can also pass SQL statements directly.# returns a DataFrame
db.sql("select count(*) from User")
# returns None
db.sql("insert into User select * from User where email = 'xxx'")
Package: fastsqlite
FastSQLite DocumentationExamplefromfastsqliteimportFastSQLitedb=FastSQLite()db.connect('file.db')db.create_table('gato','id int, rum varchar(300)')Using FastSQLitedb=FastSQLite()db.connect( file):db.connect('database.db')Important:ALTERtable [table] RENAME TO [rename];
[variable] = variable: str

db.rename_table(str, str)

example:
	db.rename_table('old_name', 'new_name')Table Actionsdb.create_table(table, columns):CREATEtable[table]([columns]);db.rename_table(table, rename):ALTERtable[table]RENAMETO[rename];db.drop_table(table):DROPtable[table];Column Actionsdb.insert(table, column, params):INSERTINTO[table]([column])VALUES([params]);db.update(table, params, where, condition):UPDATE[table]SET[params]WHERE[where]=[condition];db.delete(table, where, condition):DELETEFROM[table]WHEREWHERE[where]=[condition];db.add_column(table, new_column):ALTERtable[table]ADDCOLUMN[new_column];db.add_fk_reference(table, fk_column, column_id):FOREIGNKEY([fk_column])REFERENCES[table]([column_id]);Queries Sectiondb.custom_fetch( query):query='SELECT nombre as n, precio as p FROM productos WHERE precio < 5.60;'db.custom_fetch(query):db.fetch_all(table):SELECT*FROM[table];db.fetch_one(table, column):SELECT[column]FROM[table];db.fetch_many(table, columns):SELECT[columns]FROM[table];db.distinct(table, columns):SELECTDISTINCT[columns]FROM[table];db.where(table, columns, where, param):SELECT[columns]FROM[table]WHERE[where]=[param];db.like(table, columns, param):SELECT[columns]FROM[table]LIKE[param];db.between(table, columns, where, param1, param2):SELECT[columns]FROM[table]WHERE[where]BETWEEN[param1]AND[param2];db.left_join(table1, table2, columns, column1, column2):SELECT[columns]FROM[table1]LEFTJOIN[table2]ON[table1].[column1]=[table2].[column2];db.right_join(table1, table2, columns, column1, column2):SELECT[columns]FROM[table1]RIGHTJOIN[table2]ON[table1].[column1]=[table2].[column2];db.inner_join(table1, table2, columns, column1, column2):SELECT[columns]FROM[table1]INNERJOIN[table2]ON[table1].[column1]=[table2].[column2];db.union_all(table1, table2, columns_table1, columns_table2):SELECT[columns_table1]FROM[table1]UNIONALLSELECT[columns_table2]FROM[table2];db.union(table1, table2, columns_table1, columns_table2):SELECT[columns_table1]FROM[table1]UNIONSELECT[columns_table2]FROM[table2];db.avg(table, column, name, where, param):SELECTAVG([column])AS[name]FROM[table]WHERE[where]=[param];db.count(table, column, name, where, param):SELECTCOUNT([column])AS[name]FROM[table]WHERE[where]=[param];db.sum(table, column, name, where, param):SELECTSUM([column])AS[name]FROM[table]WHERE[where]=[param];db.max(table, column, name, where, param):SELECTMAX([column])AS[name]FROM[table]WHERE[where]=[param];db.min(table, column, name, where, param):SELECTMIN([column])AS[name]FROM[table]WHERE[where]=[param];
Package: fastsqlite3
fastsqlite3A simple and easy to use async wrapper forsqlite3.This is basically the same assqlite3except you useasync withandawaitin front of most operations.importasyncioimportfastsqlite3asyncdefmain():asyncwithfastsqlite3.connect('example.db')asconn:asyncwithconn.cursor()ascursor:# Create tableawaitcursor.execute('''CREATE TABLE stocks(date text, trans text, symbol text, qty real, price real)''')# Insert a row of dataawaitcursor.execute("INSERT INTO stocks VALUES ('2006-01-05','BUY','RHAT',100,35.14)")# Save (commit) the changesawaitconn.commit()asyncio.run(main())Differences fromsqlite3This module differs fromsqlite3in a few ways:Connections are created withjournal_modeset towal.Connections have foreign keys enabled by default.Implicit transactions are turned offTherow_factoryis set tosqlite3.Row.LicenseMIT
Package: fast-sql-manager
IntroduçãoEssa biblioteca foi criada como uma forma de abstração das operações mais simples
de um banco de dados MySQL.InícioApós fazer a instalação com o pip install fast_sql_manager
é necessário que você importe a classe correspondente ao banco
que deseja manipular.fromfast_sql_manager.implementations.mysqlimportMySQLRepositoryoufromfast_sql_manager.implementations.sqliteimportSQLiteRepositoryAo importar a classe você pode instância-la ou
usa-la diretamente preenchendo os parâmetros necessários.db=Repository(host='localhost',port=3307,user='root',passwd='root',db_name='sys')MétodoscreateDataBasePara criar um Banco de Dados basta inserir o primeiro
parâmetrodb_namecom o nome do Banco que deseja Criar.db.create_database('nome_do_banco')createTablePara criar um tabela é necessário informar apenas o nome
no parâmetronameatravés  de uma String.Para informar como devem ser as colunas o parâmetrocolunsdeve ser um dicionário, onde a chave seria o nome
da coluna e o valor os atributos da coluna.db.create_table(name='minha_tabela',columns={'id':'int not null primary key auto_increment'})selectAllPara selecionar todos os dados de uma tabela
é necessário apenas preencher através de uma
string o parâmetrotable_namepara informar
qual tabela você deseja puxar o dadosdb.select_all(table_name='nome_da_tabela')insertPara inserir os dados em uma tabela é necessário informar o nome da tabela notable_namecomo String, as colunas de deseja inserir notable_columnscomo uma Lista e os valores que deseja inserir noinsert_valuescomo uma Tupla.db.insert(table_name='pessoas',tb_columns=['cpf','nome','idade'],insert_values=('000000000','João',19))updatePara realizar o update informe o parâmetro tb_name como String.
O parâmetrosetdeve ser um Dicionário, sendo a chave a coluna que deseja alterar,
e o valor sendo o novo valor dessa coluna.
O parâmetrowheretambém é um Dicionário contendo seu primeiro par de chave e valor com a coluna que deseja
realizar o filtro where e o valor que a coluna deve conter.db.update(table_name='tab_pessoa',set={'nome':'Joãozinho','idade':17},where={'cpf':'123456789'})É possível também inserir dentro dowhereoperadores condicionais, porém o parametro muda um pouco
pois é necessário dentro do dicionário informar qual a condicional que deseja usar.db.update(tb_name='tab_pessoa',set={'nome':'Joãozinho','idade':17},where={'cpf':{'value':'123456789','condicional':'and'},'name':'João',})deletePara realizar o update informe o parâmetrotb_namecomo String.O parâmetro where também é um Dicionário contendo seu primeiro par de chave e valor com a coluna que deseja
realizar o filtro where e o valor que a coluna deve conter.db.delete('tab_pessoa',{'cpf':'123456789'})É possível também inserir dentro do where operadores condicionais, porém o parâmetro muda um pouco
pois é necessário dentro do dicionário informar qual a condicional que deseja usar.db.delete(tb_name='tab_pessoa',where={'cpf':{'value':'123456789','condicional':'and'},'name':'João',})
Package: fastsrm
FastSRMImplementation of FastSRM algorithms.The model of probabilistic SRM is given by:whereis the data of subjectis the basis of subjectis the shared response (or sources) assumed to be sampled from a centered Gaussian with covarianceis  the noise in subjectassumed to be sampled from a centered Gaussian with covariancewhereis the identity matrix. We callthe noise variance of subject.In practice we observe n samples of. When the number of samples is much lower than the number of features v, the SRM model can be fitted efficiently. This is what this repository provides. We also assume that the covariance of the shared response is diagonal to obtain identifiability.InstallClone the repositorygit clone https://github.com/hugorichard/FastSRMIn the cloned directory executepip install -e .Requirements:scipy>=0.18.0
numpy>=1.12
scikit-learn>=0.23
joblib>=1.1.0
matplotlib>=2.0.0
pytest>=6.2.5To run the experiments on identifiability, brainiak (https://github.com/brainiak/brainiak) and nilearn (https://nilearn.github.io/stable/index.html) are necessary.UsageIn many neuroscience datasets, the samples are split into sessions. Therefore, for each subject we will have several sessions that can be time-wise concatenated to obtain all samples.
InIdentifiableFastSRM# Input data X: neuroimaging data# X is a np array of shape (n_subjects, n_sessions)# X[i, j] is a path to a np array of shape (n_voxels, n_timeframes)fromfastsrm.identifiable_srmimportIdentifiableFastSRMsrm=IdentifiableFastSRM(n_components=5,temp_dir="./",n_jobs=5)S=srm.fit_transform(X)# Shared response: np array of shape (n_components, n_timeframes)W=srm.basis_list# Shared response: np array of shape (n_components, n_timeframes)Sigma=srm.source_covariance# (Diagonal) Covariance of the shared response: np array of shape (n_components,)sigmas=srm.noise_variance# Variance of the noise: np array of shape (n_subjects)Run experimentsSynthetic experimentIn theexperimentsfolder runipython synthetic.pyGo in theplottingfolder and runipython plot_synthetic_gradients.pyThe figure is now available in thefiguresfolder under the namesynthetic_gradient.pdfTimesegment matching experimentGo in the experiments folder and download the sherlock dataset by running:ipython get_sherlock.pyGo in theexperimentsfolder and runbash timesegment.bashif you have access to a cluster with slurm otherwise runbash timesegment_local.bashGo in theplottingfolder and runipython plot_timesegment.pyThe figure is now available in thefiguresfolder under the nametimesegment_matching_sherlock.pdfIdentifiability experimentGo in the experiments folder and download the sherlock dataset by running:ipython get_sherlock.pyDownload and install Brainiak (seehttps://github.com/brainiak/brainiak)Go in theexperimentsfolder and runbash identifiability.bashif you have access to a cluster with slurm otherwise runbash identifiability_local.bashGo in theplottingfolder and runipython plot_identifiability.pyThe figure is now available in thefiguresfolder under the nameidentifiability.pdfDocumentationhttps://hugorichard.github.io/FastSRM/
Package: fastss
FastSS is a string similarity searching algorithm. For each query, whichconsists of query stringsand distanced, it retrieves all the words in a
dictionary whose edit distance fromsis equal or smaller thand. FastSS is an
offline searching algorithm, as it needs to create an index of its dictionary
before it can search. For more information on FastSS you can visit the website
of its inventors at <http://fastss.csg.uzh.ch/>.Here are some of the characteristics of this implementation, to help you decide
whether it fits your purposes:Very fast searching at the cost of a rather large index size.Indices are plain sqlite databases so they carry ACID guarantees.Only unicode strings are supported.Example of usage:>>> import fastss
>>> manager = fastss.FastSSManager('idx')
>>> manager.create_index(False)
# Insert lemmas in the index, using 20% of their length as the depth:
>>> manager.update_index([u'Mike', u'Johnny', u'johnny'], lambda s: int(len(s)*.2))
# Search:
>>> for match in manager.search('Mike', 2): print match
(u'Mike', 0)
>>> for match in manager.search('johnny', 1): print match
(u'johnny', 0)
(u'Johnny', 1)
>>> for match in manager.search('johnny', 1, nocase=True): print match
(u'Johnny', 0)
(u'johnny', 0)
>>> for match in manager.search('johny', 2, nocase=True): print match
(u'johnny', 1)
(u'Johnny', 1)
Package: fast-ssg
Fast Static Site GeneratorFast Static Site Generator (Fast SSG) - a tool for generating a complete HTML files from raw data like txt and md files. This tool was made with Python language.PrerequisitesPython3BeautifulSoup4Tool installationTo install the tool run the following commandpip install fast-ssg==1.0.1Tool featuresCSS stylesheet support by specifying--stylesheetorsTitle parsing support for txt files. First line, indicates title followed by two blank lines. This will populate the<title>...</title>and add<h1>...</h1>to the top of the<body>...</body>.Title parsing support for md files. Line starting with the Markdown syntax # indicates the title. This will populate the<title>...</title>and add<h1>...</h1>to the top of the<body>...</body>.Header parsing support for md files. Lines starting with the Markdown syntax ## or ### will be parsed with<h2>...</h2>and<h3>...</h3>tags respectively.Italic syntax support for md files. Contents surrounded by Markdown Syntax*italics*will be parsed to html<i>...</i>tags.Bold syntax support for md files. Contents surrounded by Markdown Syntax**Bold**will be parsed to html<b>...</b>tags.Bold and Italic syntax support for md files. Contents surrounded by Markdown Syntax***Bold Italcs ***will be parsed with both italic and bold html tags.Link syntax support for md files. Contents in Markdown Syntax [Link](url) will be parsed to html link tags with working links.<code> block support for md files. Content surround by Markdown Syntax`code content`will be parsed to html<code>...</code>Horizontal rule support for md files. The Markdown---gets converted to an<hr>tag.If users specifies a folder for the input, automatically generates anindex.html, which has relative links to each of the generated files.Usage with shorthand flagsDescriptionCommandGenerate basic HTML file(s)fast_ssg --input "relative path or absolute path to the file or folder"Generate basic HTML file(s) with CSS stylesheetfast_ssg --input "relative path or absolute path to the file or folder" --stylesheet "URL to CSS stylesheet"New Feature: Support arguments passed with Config Filefast_ssg -c ./ssg-config.jsonHelpfast_ssg --helpGet current versionfast_ssg --versionShorthand flagsFlagShorthand version--input--i--help--h--version--v--stylesheet--s--config--cMarkdownHeaders# H1
## H2
## H3Links[Inline-style link](https://github.com)Bold & Italic**bold text**

**italic text**

***bold and italic text***Code block`var x = y + z`Horizontal rule---Markdown syntaxHTML equivalentHeader 1<h1>Test</h1>Header 2<h2>Test</h2>Header 3<h3>Test</h3>Bold<b>Test</b>Italic<i>Test</i>Link<a href='URL'>Test</a>Code<code>Code</code>Horizontal rule<hr>Live version & Project-package websitehttps://abatomunkuev.github.io/static_site_generator/
Package: fastsso
fast-ssofastssois a Python package that facilitates the integration of Keycloak authentication in applications built with the FastAPI web framework.Features 🎁Authentication with bearer JWT tokens.JWT token validation.Authorization based on roles, groups and the user's email verification state in Keycloak.Provides information about the validated user.Handy tools for checking roles, groups and other user attributes.Usage 💡MiddlewareUse KeycloakFastSSOMiddleware to protect your API routes. You must first configure the connection to Keycloak with the appropriate parameters.fromfastapiimportFastAPIfromkeycloakfastsso.middlewareimportKeycloakFastSSOMiddlewareapp=FastAPI()app.add_middleware(KeycloakFastSSOMiddleware,server_url="https://my-keycloak-url/auth/",client_id="my-client-id",realm_name="my-realm-name",client_secret_key="my-client-secret-key")DecoratorsThese decorators can be used to restrict access to routes based on user roles or groups.fromkeycloakfastsso.decoratorsimportrequire_role,require_group,require_scope,require_email_verified,require_active_user,require_token_type,require_resource_access,require_allowed_origin@app.get("/require_role")@require_role(["admin"])defrequire_role_endpoint():return{"Hello":"World"}@app.get("/require_group")@require_group(["my_group"])defrequire_group_endpoint():return{"Hello":"World"}# other routes continue the same wayUtilitiesThe utilities allow you to retrieve specific information about the currently authenticated user.fromkeycloakfastsso.utilsimportKeycloakUtils# In your route@app.get("/whoami")defwho_am_i(request:Request):return{"user_id":KeycloakUtils.get_user_id(request)}Installation 🛠️You can installkeycloakfastssowith pip:pipinstallkeycloak-fast-ssoFor more information on how to use this package, please refer to the official documentation.FastAPI avec Keycloak Fast SSO
Package: fastsst
A fast implementation of Singular Spectrum Transformation for python.Featuresfast computationefficient algorithm using lanczos method[Numba](http://numba.pydata.org/)ReferencesTsuyoshi Ide, Koji Tsuda, Change-Point Detection using Krylov
Subspace Learning, SIAM International Conference on Data Mining,
pp.515-520, 2007Tsuyoshi Ide, Speeding up Change-Point Detection using Matrix
Compression (Japanse), Workshop on Information-Based Induction
Sciences, 2006Tsuyoshi Ide, Masashi Sugiyama, Anomaly Detection and Change
Detection (Japanse), Kodansha, 2015