Saravanan666/pypi-org huggingface dataset:
Package: bam2tensor
bam2tensorbam2tensor is a Python package for converting .bam files to dense representations of methylation data (as .npz NumPy arrays). It is designed to evaluate all CpG sites and store methylation states for loading into other deep learning pipelines.FeaturesParses .bam files usingpysamExtracts methylation data from all CpG sitesSupports any genome (Hg38, T2T-CHM13, mm10, etc.)Stores data in sparse format (COO matrix) for efficient loadingExports methylation data to .npz NumPy arraysEasily parallelizableRequirementsPython 3.9+pysam, numpy, scipy, tqdmInstallationYou can installbam2tensorviapipfromPyPI:pip install bam2tensorUsagePlease see theReference Guidefor full details.Data StructureOne.npzfile is generated for each separate.bam, which can be loaded usingscipy.sparse.load_npz(). Each.npzfile contains a single sparse SciPyCOO matrix.In the COO matrix, each row represents a read and each column represents a CpG site. The value at each row/column is the methylation state (0= unmethylated,1= methylated,-1= no data). Note that-1can represent indels or point mutations.TodoConsider storing a Read ID: Row ID mapping?Export / more stably store & import embedding mapping? (.npz or other instead of .json?)Store metadata / object reference in .npz file?ContributingContributions are welcome! Please see theContributor Guide.LicenseDistributed under the terms of theMIT license,bam2tensoris free and open source.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project is developed and maintained byNick Semenkovich (@semenko), as part of the Medical College of Wisconsin'sData Science Institute.This project was generated fromStatistics Norway'sSSB PyPI Template.
Package: bamAlignCleaner
bamAlignCleanerA simple utility tool to remove references with no aligned reads in abam/cramfileInstallationwith pippipinstallbamAlignCleanerwith condacondainstall-cbiocondabamAlignCleanerUsageQuick startbamAlignCleanerinput.bamAdvancedbamAlignCleaner--outputoutput.bam--methodparseinput.bamHelp$bamAlignCleaner--help
Usage:bamAlignCleaner[OPTIONS]BAMbamAlignCleaner:removesunalignedreferencesinBAM/CRAMalignmentfiles*Homepage:https://github.com/maxibor/bamAlignCleaner*Author:MaximeBorryBAM:BAMalignmentfile(sorted,andoptionallyindexed)Options:--versionShowtheversionandexit.-m,--method[parse|index_stat]unalignedreferenceremovalmethod[default:parse]-o,--outputFILEfilteredbamfile[default:STDOUT]--helpShowthismessageandexit.MethodsbamAlignCleaner uses either one of the two following methods to remove references not having reads mapped against them.Theparsemethod goes through each read of the alignment file and keeps the references if the read maps to it.This method should be faster if you have more references than reads.Thecheck_indexchecks index for the number of mapped reads to each reference.This method should be faster if you have more reads than references.
Package: bamanro-django-markdownx
Django MarkdownX is a comprehensiveMarkdownplugin built forDjango, the renowned high-level Python web framework, with flexibility, extensibility, and ease-of-use at its core.Documentationhttps://neutronx.github.io/django-markdownx/Key featuresRaw editing.Live preview.Drag & drop image uploads (automatically stored in the designated location in theMediadirectory).Customizable image insertion tag.Definition of maximum size for an image.Definition of acceptable image formats (PNG, JPEG, SVG).Image manipulations (compression, size reduction, cropping, upscaling).Pre- and post- text modification.Easy template customization, layout modification, and personalization.Multiple editors per page.Django Admin support.Preview(using Bootstrap for layout and styling)
Package: bamboo-core
bambooSupported InterfacesWSGIASGI v3.0 (HTTP, WebSocket and Lifespan)InstallingPython: >= 3.7python -m pip install bamboo-coreUsage以下は簡単な実装例です．frombambooimportWSGIApp,WSGIEndpoint,WSGITestExecutorapp=WSGIApp()@app.route("hello")classMockEndpoint(WSGIEndpoint):defdo_GET(self)->None:self.send_body(b"Hello, World!")if__name__=="__main__":WSGITestExecutor.debug(app)上記スクリプトを実行後，ブラウザでhttp://localhost:8000/helloにアクセスするとレスポンスを確認できます．API documentationAPI ドキュメントはこちら．Examplesupsidedownリクエストされた文字列を逆順に反転させて返すアプリケーションです．image_trafficアクセスに対して静的な画像を返すアプリケーションです．tweetsCLI ベースの簡易的な Twitter のような投稿アプリです．認証機能は実装されていません．
Package: bamboo-crawler
Bamboo CrawlerDeprecation NoticeThis project is deprecated. No longer maintained.  I don't use this project anymore. If you want to use this project, please fork it.A Hobby Crawler.
It is almost under construction.UsageInstallation$pipinstallbamboo-crawlerRun$ bamboo --recipe recipe.ymlRecipemytask:input:type:ConstantInputteroptions:value:http://httpbin.org/robots.txtprocess:type:HTTPCrawleroutput:type:StdoutOutputterLicenseBSD-3-Clause License
Package: bamboo-hep
Bamboo: A high-level HEP analysis library for ROOT::RDataFrameTheROOT::RDataFrameclass provides an efficient and flexible way to process per-event information
(stored in aTTree) and e.g. aggregate it into histograms.With the typical pattern of storing object arrays as a structure of arrays
(variable-sized branches with a common prefix in the names and length),
the expressions that are typically needed for a complete analysis quickly become
cumbersome to write (with indices to match, repeated sub-expressions etc.).As an example, imagine the expression needed to calculate the invariant mass
of the two leading muons from a CMS NanoAOD file (which stores 4-momenta with
pt, eta and phi branches): one way is to construct LorentzVector objects,
sum and evaluate the invariant mass.
Next imagine doing the same thing with the two highest-pt jets that have a b-tag
and are not within some cone of the two leptons you already selected in another
way (while keeping the code maintainable enough to allow for passing jet momenta
with a systematic variation applied).Bamboo attempts to solve this problem by automatically constructing
lightweight python wrappers based on the structure of theTTree,
which allow to construct such expression with high-level code, similar to the
language that is commonly used to discuss and describe them. By constructing
an object representation of the expression, a few powerful operations can be
used to compose complex expressions.
This also allows to automate the construction of derived expressions, e.g. for
shape systematic variation histograms.Building selections, plots etc. with such expressions is analysis-specific, but
the mechanics of loading data samples, processing them locally or on a batch
system, combining the outputs for different samples in an overview etc.
is very similar over a broad range of use cases.
Therefore a common implementation of these is provided, such that the analyst
only needs to provide a subclass with their selection and plot definitions,
and a configuration file with a list of samples, and instructions how to
display them.DocumentationThe HTML documentation (with a longer introduction, installation instructions,
recipes for common tasks and an API reference of the classes and methods) is
availablehere.DevelopmentBamboo has been in development since early 2019, and is actively used by
several analyses.
The experience from daily use, and the addition of new features in the
underlying ROOT::RDataFrame package, ideas for improvements and further
development continue to pop up.
Please have a look at theguidelinesto also start contributing.
Package: bamboo-ipa-sync
Tool to synchronise FreeIPA with BambooHRPyPI package:bamboo_ipa_syncIf you spot any problems or have any improvement ideas then feel free to
open an issue and I will be glad to look into it for you.InstallationA recommended way of installing the tool is pip install.Once installed, a command line toolbamboo_ipa_syncshould be
available in your system’s PATH.pip installThe tool is available in PyPI and can be installed using pip:$ pip install --user bamboo_ipa_sync
$ bamboo_ipa_sync --helpConfigurationEdit and save the sample config fileSAMPLE_CONFIGas~/.config/bamboo_ipa_sync.The tool usesppmailmodule for sending Email/Slack notifications,
please checkppmail home pagefor more information on how to configure it.Usage$ bamboo_ipa_sync --help
usage: bamboo_ipa_sync [--version] [-l] [-b] [-s] [-n] [-f [UID [UID ...]]]
                       [-N] [--help] [--debug] [--quiet]

Tool to synchronise FreeIPA with Bamboo HR

optional arguments:
  --version             show program's version number and exit
  -l, --ldap            print LDAP data and exit
  -b, --bamboo          print Bamboo data and exit
  -s, --sync            synchronise LDAP with Bamboo
  -n, --notification    send New Starter Notification (requires -s)
  -f [UID [UID ...]], --force [UID [UID ...]]
                        force changes for given UIDs (or all if none provided)
  -N, --noop            dry-run mode
  --help                show this help message and exit
  --debug               debugging mode
  --quiet               no console output
Package: bamboolean
Bamboolean interpreterSupported from Python >= 3.6Implementation of Bamboolean - Boolean Logic LanguageBamboolean is a simple language that consumes array of pre-defined variables, and
returns boolean value if constraints on these variables are met.Exemplary expressions in the languageFeaturesCase in-sensitive variable names and keywordsComparison operators (listed below)Logic AND / OR / NOTExpressions with parenthesesTypes: Float, Int, String, Bool, VariableTruth value testing same as in PythonImplicit cast of variables to boolean when no relational operator is specifiedOperators associativityAll operators are left-associativeOperators precedence (the higher number the higher priority)ORANDNOT== | != | < | <= | > | >=TestingRun tests:`python run_tests.py`EBNF Grammarcompound_expr : expr
              | empty

expr : simple_expr (OR simple_expr)*

simple_expr : term (AND term)*

term : statement
     | LPAREN expr RPAREN
     | NOT term

statement : value
          | constraint

constraint : variable (relational_operator value)?

relational_operator : ( EQ | NE | LT | LTE | GT | GTE )

value : INTEGER
      | FLOAT
      | STRING
      | BOOL

variable : ID

empty :
Package: bamboo-lib
BambooBamboo is a library intended to facilitate the process of creating extract, transform, and load (ETL) data pipelines. Bamboo includes many features such as the ability to download and cache HTTP assets, copy files from remote servers, run commands on remote servers, handle zipped archives, perform bulk database ingests and more.Installationpip install bamboo-libAdditional StepsIf you will need to use the distributed locking functionality, you will need to install
some additional software. Below are the instructions for macOSInstalling Sherlock on macOS.brew install libmemcachedpip install pylibmc --install-option="--with-libmemcached=/usr/local/Cellar/libmemcached/1.0.18_2"pip install sherlockRunning testsTo run the tests, simply run:pytestAlternatively, if you would like to display all log/print statements run:pytest -sConfigurationTo change the default folder where Bamboo will store HTTP downloads, set theBAMBOO_DOWNLOAD_FOLDERenvironment variable. By default, downloads will go to/tmp.To change the default logger settings, setBAMBOO_LOGGER_CONFto point to a logging configuration file (see example inexample/logging.conf).Troubleshooting tipsMutli-processing issues on macOSIf you are running High Sierra or later and get an error like:objc[30911]: +[__NSPlaceholderDate initialize] may have been in progress in another thread when fork() was called. We cannot safely call it or ignore it in the fork() child process. Crashing instead. Set a breakpoint on objc_initializeAfterForkError to debugTry setting:exportOBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES
Package: bamboo-nested
bamboobamboo is a library for feeding nested data formats into pandas. The space of data representable in nested formats is larger than the space covered by pandas. pandas supports only data representable in a flat table (though things like multi-indexs allows certain types of tree formats to be efficiently projected into a table). Data which supports arbitrary nesting is not in general convertible to a pandas dataframe. In particular, data which contains multiple repetition structures (e.g. JSON arrays) that are not nested within each other will not be flattenable into a table.The current data formats supported are:JSONApache AvroApache ArrowProfobuf (viaPBD)bamboo works by projecting a flattenable portion (a subset of the nested columns) of the data into a pandas dataframe. By projecting various combinations of columns, one can make use of all the relationships implied by the nested structure of the data.InstallationTo install from PyPI:pip install bamboo-nestedExampleA minimal example of flattening a JSON string:from bamboo import from_json

obj = [{'a': None, 'b': [1, 2], 'c': [5, 6]}, {'a': -1.0, 'b': [3, 4], 'c': [7, 8]}]
node = from_json(json.dumps(obj))
    > - a float64
    > - b []uint64
    > - c []uint64Flattening just the values of columna:df_a = node.flatten(include=['a'])
    >      a
    > 0  NaN
    > 1 -1.0Flattening columnsaandb(note that columnais repeated to match the corresponding elements of columnb):df_ab = node.flatten(include=['a', 'b'])
    >      a  b
    > 0  NaN  1
    > 1  NaN  2
    > 2 -1.0  3
    > 3 -1.0  4Trying to flatten two repetition lists at the same level will lead to an error (as this structure is unflattenable without taking a Cartesian product):df_bc = node.flatten(include=['b', 'c'])
    > ValueError: Attempted to flatten conflicting listsBuildingTo build this project:Building from source requires cmake (pip install cmake) and Boost.python setup.pyUnit testsTo run the unit tests:python setup.py testor use nose:nosetests python/bamboo/testsLicensingThis project is licensed under theApache 2.0 License. It uses the pybind11, Arrow, Avro, nlohmann JSON, and PBD projects. The licenses can be found in thoseprojects' directories.
Package: bamboopy
BambooHR Python LibraryThis library eases the use of the BambooHR REST API. It is an unofficial Python API for BambooHR.This library require two additional libraries (xmltodic, rfc6266) to handle some special requests.To use this library you can dofrombamboopyimportEmployeesemployees=Employees(api_key='MYCOMPANYAPIKEY',company='companyname')employees=employees.directory()This will give you a list of employeesYou can also upload files to BambooHRfrombamboopyimportEmployeesemployees=Employees(api_key='MYCOMPANYAPIKEY',company='companyname')employees.upload_file(123,category=12,file='./Contract_template.pdf',filename="Contract.pdf")
Package: bamboo-server
bamboois an application that systematizes realtime data analysis.bambooprovides an interface for merging, aggregating and adding algebraic
calculations to dynamic datasets.Clients can interact withbamboothrough a REST web interface, a Python
library, or a JavaScript library.  For more languagesrequest a libaryin
the language you prefer.bamboosupports a simple querying language to build calculations
(e.g. student teacher ratio) and aggregations (e.g. average number of students
per district) from datasets. These are updated as new data is received.bamboousespandasfor data analysis,pyparsingto read formulas, andmongodbto serialize data.bambooisopen sourcesoftware
released under the 3-clause BSD license, which is also known as the “Modified
BSD License”.Dependenciespython (tested on version 2.7)mongodbfor numpy, pandas, and scipy:On Arch Linux:# pacman-Sblas lapackgcc-fortran.On Debian based:#apt-getinstall gfortranlibatlas-base-dev.On Mac OS X:$ brew install gfortran.Using as a Python LibaryInstallation$pipinstallbamboo-serverPython pip package forbamboo.For creating plots:$ pip install matplotlib.Usageimportbambooasbmbf=bm.BambooFrame([{'date':'2012-12-21'}])bff=bf.recognize_dates()bff.to_json()>>>'[{"date": {"$date": 1356048000000}}]'# Turn asyncronous processing offbm.set_async(False)url='http://formhub.org/mberg/forms/good_eats/data.csv'dataset=bm.Dataset.create()dataset.import_from_url(url,na_values=['n/a'])dataset.schema>>>{u'_gps_altitude':{u'cardinality':14,u'label':u'_gps_altitude',...# Resample monthly, 'M', aggregating by meandate_column='submit_date'monthly=ds.resample(date_column,'M','mean').set_index(date_column)monthly_amounts=monthly.amount.dropna()# Plot the amount spent per monthmothly_amounts.plot()Installation$./scripts/install.shExample UsageOn the remote serverrunning the example basic commands$./scripts/commands.shusingbamboo.JSvardataset=newbamboo.Dataset({url:'http://bitly.com/ZfzBwP'});bamboo.dataset_exists('nonexistentdataset_id');dataset.query_info();...usingpybamboofrompybambooimportPyBamboopybamboo=PyBamboo()response=pybamboo.store_csv_file('http://formhub.org/mberg/forms/good_eats/data.csv')dataset_id=response['id']...posting a dataset$curl-XPOST-d"url=http://formhub.org/mberg/forms/good_eats/data.csv"http://bamboo.io/datasetsDocumentationViewing DocumentationThe latest docs are available athttp://bamboo.io/AboutJoin thebamboo-dev list.bamboois an open source project. The project features, in chronological
order, the combined efforts ofPeter Lubell-DoughtieMark JohnstonPrabhas PokharelRenaud GaudinMyf MaUkang’a DicksonLarry Weyaand other developers.Projects usingbamboobamboo.io- The bamboo.io web service APIformhub- Mobile Data Collection made easyAFSIS- Africa Soil Information ServiceIs your project using bamboo?Let us know!
Package: bambou
# bambou[![Join the chat athttps://gitter.im/nuagenetworks/bambou](https://badges.gitter.im/nuagenetworks/bambou.svg)](https://gitter.im/nuagenetworks/bambou?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)Bends but does not break!## descriptionBambouis a Python ReST layer for Nuage Networks’ APIs base concepts. It works on top of therequestslibrary and provides an object oriented layer for manipulating ReST entities.Bamboucan not be used as is, and it’s mainly used by the Nuage Networks’vsdkandvspk.# LicenseCopyright (c) 2015, Alcatel-Lucent Inc.
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.Neither the name of bambou nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Package: bambu-ajax
AJAX utility functions for Django that can be accessed via a single URL
(ala WordPress admin-ajax.php)About Bambu AJAXBambu AJAX lets you write utility functions for your Django apps that
can be called via AJAX, without having to specify a separate URL pattern
and view for each one.About Bambu Tools 2.0This is part of a toolset called Bambu Tools. It’s being moved from a
namespace ofbambuto its own ‘root-level’ package, along with all
the other tools in the set. If you’re upgrading from a version prior to
2.0, please make sure to update your code to usebambu_ajaxrather
thanbambu.ajax.InstallationInstall the package via Pip:pip install bambu-ajaxAdd it to yourINSTALLED_APPSlist:INSTALLED_APPS = (
    ...
    'bambu_ajax'
)Addbambu_ajax.urlsto your URLconf:urlpatterns = patterns('',
    ...
    url(r'^ajax/', include('bambu_ajax.urls')),
)Basic usageCreate a file calledajax.phpwithin your Django app, and import the
necessary module from thebambu-ajaxpackage, like so:from bambu_ajax import site

@site.register
def my_ajax_function(request):
    return [
        'a', 'list', 'of', 'things'
    ]Using thesite.registerdecorator registers your AJAX function with
thebambu_ajaxview.To leverage this function from within a Django template, use theajaxurltemplate tag, like so:{% load ajax %}
<script>
    $.getJSON('{% ajaxurl 'my_project.my_app.my_ajax_function' %}&callback=?',
        function(data) {
            console.log(data);
        }
    );
</script>Here,my_projectshould refer to the name of your Django project,my_appshould be the name of the app you put yourajax.pyfile
in, andmy_ajax_functionis the name of the function you defined
withinajax.py.The notation is similar to that used when referring to Django models, in
that you always skip the common portionajaxfrom the naming
convention.ShortcutMake your life easier by including the utility library in your template:<script src="{% url 'ajax_utility' %}"></script>
<script>
    bambu.ajax.get('my_project.my_app.my_ajax_function',
        function(data) {
            console.log(data);
        }
    );
</script>This achieves the same result, but in a much cleaner way.Dynamically updating page contentAs well as returning JSON-serialisable data per the examples above, you
can also use AJAX functions just like views, in that they can return anHttpResponseobject.Using that method, the example above would print out the HTML (or other
data) returned in the HTTP response.Additional decoratorsYou can of course add other decorators, just as you would with normal
views.TodoAdd a dedicatedlogin_requireddecorator that returns a more
helpful response for anonymous usersLook into integrating this withPlunja, my dynamic
JavaScript templating library.Questions or suggestions?Find me on Twitter (@iamsteadman) orvisit my blog.
Package: bambu-api
Quickly expose your models to a JSON or XML API, authenticated via HTTP
or OAuth.About Bambu APIThis package allows you to easily expose Django models to RESTful
endpoints which can send data in XML or JSON format.About Bambu Tools 2.0This is part of a toolset called Bambu Tools. It’s being moved from a
namespace ofbambuto its own ‘root-level’ package, along with all
the other tools in the set. If you’re upgrading from a version prior to
2.0, please make sure to update your code to usebambu_apirather
thanbambu.api.InstallationInstall the package via Pip:pip install bambu-apiAdd it to yourINSTALLED_APPSlist:INSTALLED_APPS = (
    ...
    'bambu_api'
)Addbambu_api.urlsto your URLconf:urlpatterns = patterns('',
    ...
    url(r'^', include('bambu_api.urls')),
)The prefix should be kept blank, as the package exposes two main URL
stems:/api/, wherein the RESTful endpoints live, and/docs/where auto-generated documentation for each endpoint is found.Basic usageYou define API endpoints like Django admins, and register them in a
similar way.Teka the Django ‘polls’ app as an example. Within the polls directory,
you’d create a file called api.py. A simple API endpoint would be
defined like this:from bambu_api import ModelAPI, site
from myproject.polls.models import Question

class QuestionAPI(ModelAPI):
    pass

site.register(Question, QuestionAPI)This registers theQuestionAPIendpoint for theQuestionmodel.
The endpoint is then accessible at/api/polls/question.json.Full documentationFull documentation can be found atReadTheDocs.Questions or suggestions?Find me on Twitter (@iamsteadman) orvisit my blog.