Saravanan666/pypi-org huggingface dataset:
Package: baredSC
baredSCbaredSC (Bayesian Approach to Retreive Expression Distribution of Single Cell) is a tool that uses a Monte-Carlo Markov Chain to estimate a confidence interval on the probability density function (PDF) of expression of one or two genes from single-cell RNA-seq data. It uses the raw counts and the total number of UMI for each cell. The PDF is approximated by a number of 1d or 2d gaussians provided by the user. The likelihood is estimated using the asumption that the raw counts follow a Poisson distribution of parameter equal to the proportion of mRNA for the gene in the cell multiplied by the total number of UMI identified in this cell.DocumentationVisitour documentationto see the possible options and follow the tutorials.CitationIf you are using baredSC, please cite ourbiorxiv paper.
Package: bare-estate
Bare EstateTable of ContentsAboutConfigurationUsageInstallCreditsAboutHave you ever needed to install a brand new Linux distro or BSD system? Any
experient user has done this at least a couple times, and certainly has a
dotfiles repository somewhere. But how would you transfer your dotfiles? Maybe
with symbolic links, copying files from a cloned repository, flash drive or
perhaps a combination of those.With Bare Estate you don't need a convoluted strategy for managing your
dotfiles. You can create a bare repository that will store your repository's
data. Manage your dotfiles as if they were on a regular repo. Even files from
your home directory, without actually turning your home into a git repository
itself.And the best part is the application handles the abstraction for you,
so you can use it in the same you use git!ConfigurationThe configuration is made by using a json file. The path of the file is${XDG_CONFIG_HOME}/bare_estate.json. If you didn't set the value of theXDG_CONFIG_HOMEenvironment variable, then it defaults to${HOME}/.config/bare_estate.json.Config Options:history_location: it says where your bare repository directory will be
located. Environment variables don't expand. So you will have to write the
complete path of the file.base_directory: the directory from where you will manage all your dotfiles.
You can either put them directly in the base directory, or in subdirectories
within it.Examples:bare_estate.json:{"history_location":"/home/lucas/.local/share/bare_estate","base_directory":"/home/lucas"}UsageThe package introduces an executable script calledestateas the main
entrypoint for the application. It is used just like you would use git.Examples:Initialize a new repo:estateinitClone an existing repository:estateclone<dotfiles-repo-url>Warning: cloning a repository will overwrite your local files if the remote
repository has files with the same name.Add files to the staging area:estateaddfile1file2file3Check your repository's status:estatestatusCommit your changes:estatecommitPush your changes to the remote repo:estatepushInstallTo install this package from the PyPI, you can use the command:pipinstall-Ubare-estateThe current version has no Python dependencies, other than the base install.
However, it requiresgitandrsyncinstalled locally in order to work.CreditsGreg Owen, for theblog postthat inspired this projectStreakyCobra and the other users fromHacker News
Package: bareimport
bareimport - Import a python file even if it does not end in ".py".This module is useful for building tests of functions within standalone scripts.
This allows you to have a standalone script file, without having to name it ending in
".py".  Then you can create test files that:import bareimport
mod = bareimport.import_script_as_module('mod', ['./mod', '../mod'])

#  You can also import "mod" now:
from mod import funcLicenseCC0 1.0 Universal, see LICENSE file for more information.
Package: barely-db
Copyright (c) 2020 Deniz BozyigitPermission 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.Description: # barely-dbAn opinionated database for small teams powered by conventions.Platform: UNKNOWN
Package: barely-json
Barely JSONA Python package for parsing data that only looks like JSONfrom barely_json import parse
print(parse('[what is this?, , {perhaps, json: no}]'))

# Prints ['what is this?', '', {'perhaps': '', 'json': False}]Quite a bit of data looks like JSON at a first glance but turns out not to comply completely with the JSON specification -- often because the exporting software is broken, but sometimes simply because the format was never intended to be JSON in the first place.No matter how you ended up with the data, now you want to parse it! However, most JSON parsers are pretty strict, so you're out of luck with your JSON-esque mess.That's whereBarely JSONsteps in and tries to parse anything that remotely looks like JSON. In addition to the pure parsing,Barely JSONwill also try to post-process your data into suitable Python types even if your data provider uses, for example,onandoffas boolean literals.InstallationThe supported Python versions are 3.7 and later.pip install barely_jsonUsageThe main routine isparse:> from barely_json import parse
> parse("[NaN, , {state: off, where's my value?}, NULL]")

[nan, '', {'state': False, "where's my value?": ''}, None]As you can see,parseby default tries to convert values that are illegal in JSON into hopefully appropriate Python types, which often works well. But sometimes that's not what you want, so you can disable the auto-conversion:> parse("[NaN, , {state: off, where's my value?}, NULL]", resolver=None)

[<IllegalValue 'NaN'>,
 <IllegalValue ''>,
 {<IllegalValue 'state'>: <IllegalValue 'off'>,
  <IllegalValue "where's my value?">: <IllegalValue ''>},
 <IllegalValue 'NULL'>]In that case any value that's illegal or missing is wrapped in an instance of a specialIllegalValueclass. You can also provide your own resolver for illegal values, which is simply a callback that maps strings to arbitrary values:> from barely_json import default_resolver
>
> def my_resolver(text):
>     if text.lower() == 'one':
>         return 1
>     return default_resolver(text)
>
> parse('[one, FALSE]', resolver=my_resolver)

[1, False]When writing your own resolver it's often handy to fall back todefault_resolverafter you've handled your special cases.Change LogSeeCHANGELOG.md.LicenseDistributed under the MIT license. See the fileLICENSEfor details.Contributors@torfsen@tusharmakkar08@gvxDevelopmentClone the repository:git clone https://github.com/torfsen/barely_json.git
cd barely_jsonInstall the development dependenciespip install -r requirements-dev.txtRun the tests:toxFor pull requests, the tests are run using GitHub actions.
Package: bareml
baremlis a set of "bare" implementations of machine learning / deep learning algorithms from scratch (only depending on numpy) in Python. "bare" means to aim at:Code as a direct translation of the algorithm / formulaWith minimum error handling and efficiency gain tricksTo maximise understandability of the code, interface of modules inbareml/machinelearning/is aligned toScikit-learn, and interface of modules inbareml/deeplearning/is aligned toPyTorch, as seen in below 2 examples.Example1:from bareml.machinelearning.utils.model_selection import train_test_split
from bareml.machinelearning.supervised import KernelRidge

# assume the data X, y are defined
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

reg = KernelRidge(alpha=1, kernel='rbf')
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)
print(reg.score(X_test, y_test))Example2:from bareml.deeplearning import layers as nn
from bareml.deeplearning import functions as F

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, stride=1)
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1)
        self.dropout1 = nn.Dropout(p=0.25)
        self.dropout2 = nn.Dropout(p=0.5)
        self.fc1 = nn.Linear(in_features=33856, out_features=128)
        self.fc2 = nn.Linear(in_features=128, out_features=10)

    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = F.max_pool2d(x, 2)
        x = self.dropout1(x)
        x = x.flatten()
        x = self.fc1(x)
        x = F.relu(x)
        x = self.dropout2(x)
        x = self.fc2(x)
        return xInstallation$ pip install baremlor$ git clone https://github.com/shotahorii/bareml.git
$ cd bareml
$ python setup.py installDependenciesMandatorynumpyOptionalcupyPILmatplotlibExamplesGenerating handwriting digits by GAN[Google Colab]ImplementationsDeep LearningPytorch-like Deep Learning FrameworkSupervised LearningBernoulli Naive BayesDecision TreesElastic NetGaussian Naive BayesGeneralised Linear ModelK Nearest NeighborsKernel Ridge RegressionLasso RegressionLinear RegressionLogistic RegressionPerceptronPoisson RegressionRidge RegressionUnsupervised LearningKMeans (KMeans++)DBSCANEnsemble LearningAdaBoostAdaBoost M1AdaBoost SammeAdaBoost RTAdaBoost R2BaggingGradient BoostingRandom ForestStackingVotingXGBoostUtilitiesPreprocessing (Scaler, Encoder etc)MetricsKernel functionsProbability DistributionsModel Selection (KFold etc)ReferencesDeep learning programs are based on O'Reilly Japan's book "Deep learning from scratch 3" (Koki Saitoh) and its implementationDezero.References of machine learning programs are documented in each source file, but mostly based on original papers, "Pattern Recognition and Machine Learning" (Christopher M. Bishop) and/or "Machine Learning: A Probabilistic Perspective" (Kevin P. Murphy).
Package: barenames
BarenamesCommandline tool for batch renaming files using regular expressions.UsageUsage: barenames [OPTIONS] PATTERN REPLACEMENT

  Batch file rename tool with regex substitution.

  Example:

      barenames "myfile-(\d+)" "yourfile-\g<1>"

Options:
  --dir PATH                Directory to perform actions in (default: current
                            working directory)
  --preview / --no-preview  Show preview of renames with confirmation prompt.
  -r, --recursive           Search files to rename recursively
  --help                    Show this message and exitBarenames uses regex to change file names, which is very powerful tool.
But power comes with responsibility,it is adviced to use--previewoption to
view what program is gonna do, before it does it, cause with regex you never truly know....Change file extension:This example changes extension of all.mdfiles in
current working directory to.rstbarenames--preview"(?P<filename>.+)\.md""\g<filename>.rst"If your files are not in current working directory just pass--diroption to override dir.barenames--dir~/my-notes/--preview"(?P<filename>.+)\.md""\g<filename>.rst"If you wish to rename files in subdirectories too, use--recursiveor-rfor short.barenames--recursive--preview"(?P<filename>.+)\.md""\g<filename>.rst"Use this option with caution though.
Package: bareos-restapi
Bareos REST API using fastAPI and python-bareosExperimental and subject to enhancements and changes.This is an experimental backend for development purposes.It provides a REST API using fastapi and python-bareos to connect to
a Bareos director.https://fastapi.tiangolo.com/https://www.openapis.org/GuideInstallationWe recommend to create a dedicated Python environment for the installation in an own directory:python3 -m venv env
# Activate the virtual environment inside the directory
source env/bin/activate
# Install dependencies into the virtual environment
pip install bareos-restapiNote: The optional modulesslpskcan be installed manually, if you want encrypted communication between the API and the Bareos director.ConfigurationThe module directory contains a sample ini-file. Change into this directory (something like/lib/python3.x/site-packages/bareosRestapiModelson most operating systems) and copyapi.ini.sampletoapi.iniand adapt it to your director. Make sure to generate an own secret-key for theJWTsection.Your director configuration inapi.inishould look like:[Director]
Name=bareos-dir
Address=127.0.0.1
Port=9101Note: you will need anamed console(user/password) to acces the Bareos director using this API. Read more about Consoles here:https://docs.bareos.org/Configuration/Director.html#console-resourceStart the backend serverFrom inside the module directory run:uvicorn bareos-restapi:app --reloadServe the Swagger UI to explore the REST API:http://127.0.0.1:8000/docsAlternatively you can use the redoc format:http://127.0.0.1:8000/redocBrowseThe Swagger UI contains documentation and online-tests. Use "authorize" to connect to your Bareos director using a named console. Read here to learn how to configure
a named console:https://docs.bareos.org/Configuration/Director.html#console-resourceThe Swagger documentation also contains CURL statements for all available endpoints.Future workThe API will be extended by some methods provided by the Bareos console, that are not yet implemented. It is also planned to add delete / update options for configuration in the director and REST API. If you are interested in support and / or funding enhancements, please visithttps://www.bareos.comTODO:define and document response modeladd possibility to connect to a choice of directorsadd start-script with ini-file name as parameter
Package: bare-script
BareScript is a light-weight scripting and expression language.LinksThe BareScript LanguageThe BareScript LibraryThe BareScript Expression LibraryAPI DocumentationSource codeExecuting BareScriptTo execute a BareScript script, parse the script using theparse_scriptfunction. Then execute the script using theexecute_scriptfunction. For example:>>> from bare_script import execute_script, parse_script
...
>>> # Parse the script
... script = parse_script('''\
... # Double a number
... function double(n):
...     return n * 2
... endfunction
...
... return N + ' times 2 is ' + double(N)
... ''')
...
>>> # Execute the script
... globals = {'N': 10}
>>> print(execute_script(script, {'globals': globals}))
10 times 2 is 20The BareScript LibraryThe BareScript Libraryincludes a set of built-in functions for mathematical operations, object manipulation, array
manipulation, regular expressions, HTTP fetch and more. The following example demonstrates the use
of thesystemFetch,objectGet, andarrayLengthfunctions.>>> import urllib.request
...
>>> from bare_script import execute_script, fetch_http, parse_script
...
>>> # Parse the script
... script = parse_script('''\
... # Fetch the BareScript library documentation JSON
... docs = jsonParse(systemFetch('https://craigahobbs.github.io/bare-script-py/library/library.json'))
...
... # Return the number of library functions
... return 'The BareScript Library has ' + arrayLength(objectGet(docs, 'functions')) + ' functions'
... ''')
...
>>> # Execute the script
... print(execute_script(script, {'fetchFn': fetch_http}))
The BareScript Library has 106 functionsEvaluating BareScript ExpressionsTo evaluate aBareScript expression,
parse the expression using theparse_expressionfunction. Then evaluate the expression using theevaluate_expressionfunction.Expression evaluation includes theBareScript Expression Library,
a set of built-in, spreadsheet-like functions.For example:>>> from bare_script import evaluate_expression, parse_expression
...
>>> # Parse the expression
... expr = parse_expression('2 * max(a, b, c)')
...
>>> # Evaluate the expression
... variables = {'a': 1, 'b': 2, 'c': 3}
>>> print(evaluate_expression(expr, None, variables))
6.0The BareScript Command-Line Interface (CLI)You can run BareScript from the command line using the BareScript CLI, “bare”. BareScript script
files use the “.bare” file extension.barescript.bareNote:In the BareScript CLI, import statements and thesystemFetchfunction read non-URL paths from the local file system.MarkdownUp, a Markdown Viewer with BareScriptMarkdownUpis a Markdown Viewer that executes BareScript embedded within Markdown documents.MarkdownUpextends itsstandard librarywith functions for dynamically rendering Markdown text, drawing SVG images, etc.For example:# Markdown ApplicationThis is a Markdown document with embedded BareScript:~~~ markdown-scriptmarkdownPrint('Hello, Markdown!')~~~DevelopmentThis package is developed usingpython-build.
It was started usingpython-templateas follows:template-specializepython-template/template/bare-script-py/-kpackagebare-script-kname'Craig A. Hobbs'-kemail'craigahobbs@gmail.com'-kgithub'craigahobbs'
Package: baresql
baresql : playing SQL directly on Python datasbaresql improves sql agility of python data science beginners by :allowing sql over python objects (list, ranges, …) and SQL Tables,requiring no special module except : pandas.Inspiration :pypi.python.org/pypi/pandasql : sqldf for pandaspypi.python.org/pypi/ipython-sql :  sql magic in IpythonFeaturesquery lists , tuple, dictionnaries, dataframesresult as a dataframe, list of records, or listbasic Common Table Expression support on old python3.3- versionsInstallationYou can install, upgrade, uninstall sqlite_bro.py with these commands:$ pip install baresql
$ pip install --upgrade baresql
$ pip uninstall baresqlor just launch it from IPython with %loadhttps://raw.githubusercontent.com/stonebig/baresql/master/baresql/baresql.pyBasic Examplefrom __future__ import print_function, unicode_literals, division  # if Python2.7
from baresql import baresql
bsql = baresql.baresql(keep_log = True )
bsqldf = lambda q: bsql.df(q, dict(globals(),**locals()))

users = ['Alexander', 'Bernard', 'Charly', 'Danielle', 'Esmeralda', 'Franz']
#  We use the python 'users' list like a SQL table
sql = "select 'Welcome ! ' , c0 from users$$"
bsqldf(sql)Exampleshttp://nbviewer.ipython.org/github/stonebig/baresql/blob/master/examples/baresql_with_cte.ipynbLinksFork me on GitHubChangelog2016-09-18a : v0.7.4 ‘pandas walk’bug fix: pandas 0.19 compatibility fixolder versions :0.7.3 : Python keyword is ‘pass’, not ‘Pass’0.7.2 : support space in dataframe column title0.7.1 : cleanups0.7.0 : support of pandas 0.14 sqlalchemy0.6.6 : sqlite_py_manager.py browser added functions and fix, fix tokenizer error in baresql0.6.4 : minimal compatibility of sqlite_py_manager.py with old versions : python 2.7 and sqlite 3.6.210.6.1 : a pure standard-installation Python SQLite browser in examplessqlite_py_manager.py0.6 : first version with correct mysql support0.5.1 : bug correction + SQLite3.8.3 beta from 2013-01-220.5 : use SQLite true CTE if SQLite >= 3.8.30.4.1 : inline CTE when syntax is “with x as (y)”0.4 : rewrite with token0.3.2 : support comments in the SQL0.3 : includes a basic CTE0.2 : add “range(10)” iterable object support0.1 : initial version
Package: bareun-apis
What is this?bareun-apisis the generated python classes of GRPC API for bareun.ai.The bareun.ai provides several service for deep learning NLP features.
This api has all of main features, which provides tokenizing, POS tagging for Korean.
It has also customized dictionary service.How to installpip3installbareun-apisHow to useYou can create your own baikal language service client.It is used forbareunlpy, the official bareun package for python.fromgoogle.protobuf.json_formatimportMessageToDictimportbareun.language_service_pb2aspbimportbareun.language_service_pb2_grpcaslsMAX_MESSAGE_LENGTH=100*1024*1024classBareunLanguageServiceClient:def__init__(self,remote):channel=grpc.insecure_channel(remote,options=[('grpc.max_send_message_length',MAX_MESSAGE_LENGTH),('grpc.max_receive_message_length',MAX_MESSAGE_LENGTH),])self.stub=ls.LanguageServiceStub(channel)defanalyze_syntax(self,document,auto_split=False):req=pb.AnalyzeSyntaxRequest()req.document.content=documentreq.document.language="ko_KR"req.encoding_type=pb.EncodingType.UTF32req.auto_split_sentence=auto_splitres=self.stub.AnalyzeSyntax(req)# print_syntax_as_json(res)returnresdeftokenize(self,document,auto_split=False):req=pb.TokenizeRequest()req.document.content=documentreq.document.language="ko_KR"req.encoding_type=pb.EncodingType.UTF32req.auto_split_sentence=auto_splitres=self.stub.Tokenize(req)# print_tokens_as_json(res)returnresdefprint_syntax_as_json(res:pb.AnalyzeSyntaxResponse,logf=sys.stdout):d=MessageToDict(res)importjsonjson_str=json.dumps(d,ensure_ascii=False,indent=2)logf.write(json_str)logf.write('\n')defprint_tokens_as_json(res:pb.TokenizeResponse,logf=sys.stdout):d=MessageToDict(res)importjsonjson_str=json.dumps(d,ensure_ascii=False,indent=2)logf.write(json_str)logf.write('\n')
Package: barge
Easy enums for Python.>>>RGB=StringEnum(['Red','Green','Blue'])>>>RGB.Red'Red'Contents1Installation2Features3Use4Contributing4.1Installing for development4.2Running the tests4.3Adding documentation5Credits1InstallationInstallezenumwith:pipinstallezenum2FeaturesPure Python.Compatible with Python 3.5+.Easy creation of usefull enum objects.String enums with unified value and name attributes.3UseStringEnumEasilly get a string enum from a string list.4ContributingPackage author and current maintainer is Shay Palachy (shay.palachy@gmail.com); You are more than welcome to approach him for help.4.1Installing for developmentClone:gitclonegit@github.com:shaypal5/ezenum.gitInstall in development mode with test dependencies:cdezenumpipinstall-e".[test]"4.2Running the testsTo run the tests, use:python-mpytest--cov=ezenum4.3Adding documentationThis project is documented using thenumpy docstring conventions, which were chosen as they are perhaps the most widely-spread conventions that are both supported by common tools such as Sphinx and result in human-readable docstrings (in my personal opinion, of course). When documenting code you add to this project, please followthese conventions.5CreditsCreated by Shay Palachy (shay.palachy@gmail.com).
Package: bargets
AboutBargets is a small set of tiny but nice little widgets to be used in a statusbar, such
as Polybar, i3bar etc.Where does the name, "bargets", come from? [Bar] Wid[gets].Installationbargetsrequirespython3.10, so the way to install is:python3.10-mpipinstallbargetsUsageTo use a widget in your statusbar, simply provide path to the widget in your
statusbar's config. Make sure to check wherepipinstalled the widgets, by
typingwhich <widget name>against any of the widgets, so that you know what
path to use.Example: polybarThe following is a snippet of how you could use the battery widget withpolybar:[battery]type=custom/scriptexec=$HOME/.local/bin/bargets-batteryinterval=5Configuration: bargets.yamlIf you wish, you can configure each widget how you like inbargets.yaml.
First, you need to create a file calledbargets.yamlto ~/.config/bargets.
You can copy example configuration fromhere.WidgetsWidgetCommandCPUbargets-cpuBatterybargets-batteryRequirementsRequirementNotePython3.10 or higherOSMacOS, LinuxTodoAdd testsAdd command line optionsAdd screenshot(s)