Saravanan666/pypi-org huggingface dataset:
Package: tabulate-cell-merger
Tabulate Cell MergerThis is a package to merge cells when tabulating table. A table is a list of lists which can be represented into rows and columns.
It is inspired in the already existing tabulate package.How to import the moduleModule's name for importing:import tabulate_cell_merger.tabulate_cell_mergerHow to useThe module containsonefunction for you to use:tabulate(). This function accepts three arguments as following:tabulate(table, colspan, rowspan)colspanandrowspanare optional arguments. Thetableargument is required.To merge cellshorizontally, use the colspan argument.To merge cellsvertically, use the rowspan argument.These arguments aredictionaries.They allow you to stretch cells over others.Syntax:colspan = {(y, x): value}
rowspan = {(y, x): value}For each cell you want to stretch, you have to associate its coordinates, having then a tuple as key, to a stretching value: 1 generates no stretching, 2 stretches over one other cell (to the right or to downwards), etc.Here,yis the cell row,xthe cell column, andvaluethe stretching value.An exampleInput:table = [['a1', 'b1'], ['a2', 'b2']]
colspan = {(0, 0): 2}
rowspan = {(0, 1): 2}Output:+----+----+
| a1      |
+----+    +
| a2 |    |
+----+----+
Package: tabulatepdf
A CLI fortabula-pyInstallationInstall using pip:pipinstalltabulatepdfInstall from Githubgitclonehttps://github.com/Weizhang2017/tabulatepdfcdtabulatepdfpythonsetup.pyinstallCLIusage:tabulatepdf[-h]--pdfpdf[--outputoutput][--pagepage]extracttablesfrompdf

optionalarguments:-h,--helpshowthishelpmessageandexit--pdfpdfpdffiletoextracttablesfrom--outputoutputoutputfilename,default:output.csv--pagepagepagenumberofpdftoextractfrom,default:1Simple Example:tabulatepdf--pdfsample.pdf--outputoutput.csv--page10tablesavedtooutput.csv
Package: tabulationhashing
Tabulation HashingThis is an implementation of a tabulation hashing scheme for inputs of
32 or 64 bits and hashes of 32 or 64 bits.Implementation and performance analysis:https://book-of-gehn.github.io/articles/2023/03/30/Tabulation-Hashing.htmlWiki:https://en.wikipedia.org/wiki/Tabulation_hashing
Package: tabuletta
tabulettaInstallationInstalling this library is super easy!pipinstalltabulettaIntroTbuletta is a python library that print's arrays in a tabular form with some customisation.ExampleThis library is extremly simple, to use it make a list of lists, each inner list should be a row. The amount of elements in each inner list needs to be uniform.For example,table=[[5,2,3.5],[4.1,900,2],["Sup",5,1]]Will print:+-----------------+
| 5   | 2   | 3.5 |
| 4.1 | 900 | 2   |
| Sup | 5   | 1   |
+-----------------+It can also print:+-----------------+
| 5   | 2   | 3.5 |
+-----+-----+-----+
| 4.1 | 900 | 2   |
| Sup | 5   | 1   |
+-----------------+It's all your choice.Using tabulettaTo use tabuletta, simply import tabuletta after following the installation instructions from aboveimporttabulettaThen, create the list you would like to printmyList=[["Reg no","Email"],["20ABC1000","John@fakeemail.com"],["21BCD0001","Wick@fakeemail.com"]]Then simply print it! Choose whether or not you would like field names (useTrueif so, don't put anything if not (don't includeuseFieldNamesat all) because it defaults toFalse).# NOTE: useFieldNames defaults to False, so, if you don't type useFieldNames=True it automatically goes to Falsetabuletta.printTable(myList,useFieldNames=True)As output, you get:+-----------------------------------------------+
| Reg no                  | Email              |
+-----------------------+-----------------------+
| 20ABC1000               | John@fakeemail.com |
| 21BCD0001               | Wick@fakeemail.com |
+-----------------------------------------------+If you didn't want to use field names then you would only have to write:tabuletta.printTable(myList)Another example:myList=[["","a","b"],["x","a + x","a + b"],["z","a + z","z + b"]]From that, you get:+-----------------------+
|       | a     | b     |
+-------+-------+-------+
| x     | a + x | a + b |
| z     | a + z | z + b |
+-----------------------+Using colorsYou might want to use colors in tabuletta.To use them simply use RGB values, so, using the example from above:importtabulettamyList=[["","a","b"],["x","a + x","a + b"],["z","a + z","z + b"]]# give the color nametabuletta.printTable(myList,useFieldNames=True,color="red")As output you get:Some more examples of colors:The available color options are : red, blue, orange, cyan, pink, green, yellow
Package: tabulous
tabulousA table data viewer for Python.→📖 Documentationtabulousis highly inspired bynapariin its design and API.InstallationInstall all the dependencies including functionalities of loading sample data, plotting, etc.pip install tabulous[all]Install with PyQt backend.pip install tabulous[pyqt5]  # Use PyQt5
pip install tabulous[pyqt6]  # Use PyQt6Examples of Supported FunctionalitiesTable sorting and table filteringSortFilterYou can apply pre-defined or custom sorting/filtering functions to tables.
Data edition during sorting/filtering is also supported.Command paletteCouldn't find how to do it? Open the command palette and search for it!Excel-like referenced in-cell evaluationCallnumpyandpandasfunctions directly in cells.Rich visualizationSet colormaps that will help you to browse table data.Custom widget integrationAdd your ownPyQt/magicguiwidgets to the application.
Package: taccjm
TACC Job Manager is a lightweight python library for managing
HPC resources provided by the Texas Advanced Computing Center (TACC).DescriptionTACCJM manages ssh connections to TACC systems for deploying applications, running jobs, and downloading/uploading data.
These connections to are maintained by a locally deployed server that exposes an API to access TACC connections via http endpoints.
This gives the user several methods to establish and maintain connections to TACC resources programmatically and without repeated 2-factor authentication.
Furthermore the application and job hierarchy makes it easier to create reproducible and shareable HPC workflows for research.RequirementsUsing taccjm requires a TACC account enable with 2-fa. In order to run jobs
on TACC systems as well, you will need a valid allocation associated with your
user ID. Finally, your TACC user account needs to have 2-factor authentication
enabled. See theTACC user portalInstallationTo install use pip:pipinstalltaccjmA docker image for taccjm is in development and will hopefully be available in a future release.RequirementsATACC user portalis required to use the TACC Job Manager library. Furthermore allocations on one of the available TACC HPC systems is required to run jobs.WarningTACC Job Manager allows you to programmatically access TACC resources.
Please be responsible in your access and usage of TACC resources.
Review the [TACC Usage Policy](https://portal.tacc.utexas.edu/tacc-usage-policy) carefully before using any TACC resources.This project has been set up using PyScaffold 4.0.2. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: tacco
TACCO: Transfer of Annotations to Cells and their COmbinationsTACCO is a python framework for working with categorical and compositional annotations for high-dimensional observations, in particular for transferring annotations from single cell to spatial transcriptomics data. TACCO comes with an extensive ever expandingdocumentationand a set ofexample notebooks. If TACCO is useful for your research, you can citeNat Biotechnol (2023).How to install TACCOCleanThe simplest way to install TACCO is to create a clean environment withcondausing theenvironment.ymlfile from the TACCO repository:conda env create -f "https://raw.githubusercontent.com/simonwm/tacco/master/environment.yml"(For older versions ofcondaone needs to download theenvironment.ymland use the local file for installation.)CondaTo install TACCO in an already existing environment, usecondato install from theconda-forgechannel:conda install -c conda-forge taccoPipIt is also possible to install from pypi viapip:pip install taccoThis is however not recommended. Unlikeconda,pipcannot treat python itself as a package, so if you start with the wrong python version, you will run into errors with dependencies (e.g. at the time of writing,mkl-serviceis not available for python 3.10 andnumbanot for 3.11).GithubTo access the most recent pre-release versions it is also possible to pip-install directly from github:pip install tacco@git+https://github.com/simonwm/tacco.gitObviously, this is not recomended for production environments.How to use TACCOTACCO features a fast and straightforward API for the compositional annotation of one dataset, given as an anndata objectadata, with a categorically annotated second dataset, given as an anndata objectreference. The annotation is wrapped in a single function callimport tacco as tc
tc.tl.annotate(adata, reference, annotation_key='my_categorical_annotation', result_key='my_compositional_annotation')where'my_categorical_annotation'is the name of the categorical.obsannotation inreferenceand'my_compositional_annotation'is the name of the new compositional.obsmannotation to be created inadata. There are many options for customizing this function to call e.g. external annotation tools, which are described in thedocumentation of theannotatefunction.As the TACCO framework contains much more than a compositional annotation method (single-molecule annotation, object-splitting, spatial co-occurrence analysis, enrichments, visualization, ...), itsdocumentationdoes not fit into a README.
Package: tache
TacheTache 是一个 Python 的缓存框架。它基于如下的目标而设计:同时支持 Python2 和 Python3支持缓存普通函数/实例方法/类方法/静态方法支持 Batch 批量缓存支持基于 Tag 的缓存和失效支持基于参数显式声明 key 格式Documention项目地址ContentsTag 详细用法使用关键字参数Cache 空值与缓存穿透Features默认缓存空值，防止穿透基于tag 批量失效缓存batch 批量缓存支持YAMLJSONPICKLE多种 Backend SerializerGetting Started基本用法import random
import fakeredis
from tache import RedisCache

redis_client = fakeredis.FakeStrictRedis()
cache = RedisCache(conn=redis_client, format="JSON")

@cache.cached()
def add(a, b):
    return a + b + random.randint(1,100)

result1 = add(5, 6)
# 缓存生效值不变
assert add(5, 6) == result1
# 失效缓存
add.invalidate(5, 6)
assert add(5, 6) != result1基于 tag 的批量缓存失效tag 可以是固定也可以是动态的，其中动态参数代表在函数中的参数位置。
失效某个 tag 时，代表这个函数下拥有相同 tag 的缓存全部失效。@cache.cached(tags=["a:{0}"])
def add(a, b):
    return a + b + random.randint(1,100)

result1 = add(5, 6) 
result2 = add(5, 7)
add.invalidate_tag("a:5")
assert result1 != add(5, 6) 
assert result2 != add(5, 7)refresh 刷新缓存当调用refresh 时，将会重新刷新缓存并返回最新值。class A(object):

    def __init__(self):
        self.extra = 0

    @cache.cached()
    def add(self, a, b):
        self.extra += 1
        return a + b + self.extra

a = A()
assert a.add(5, 6) == 12
assert a.extra == 1
assert a.add.refresh(5, 6) == 13
assert a.extra == 2batch 缓存模式@cache.batch()
def get_comments(*comment_ids):
    return [get_comment(c) for c in comment_ids]

get_comments(1,2,3,4,5) # no cache, 调用完毕全部缓存
get_comments(2,3,4,5,6) # 2,3,4,5 从缓存中取，6 在调用完缓存
get_comments.invalidate(3,4,5) # 失效 3,4,5 的缓存显式声明 KeyTache 允许你显式声明 Key 的生成规则， 不论代码如何重构, 生成的 key 都不会改变。class B:

    def __init__(self):
        self.count = 0

    @cache.cached("counter.B.add|{0}-{1}")
    def add(self, a, b):
        self.count += 1
        return a + b + self.countNotice支持classmethod/staticmethod描述符, 但在使用classmethod时目前必须把classmethod放在内层class AC(object):

    @cache.cached()
    @classmethod
    def add(cls, a, b):
        return a + b + random.randint(1,100)设置 namespace, 处理对象属性修改的问题key 的生成规则默认为namespace:module.classname.func|arg1-arg2|tag1-tag2。
其中namespace为空,classname不存在时也为空。class A(object):
    @cache.cache(namespace="v1")
    def add(self, a, b):
        return db.execute(sql).fetchone()这个例子中，如果数据库字段发生更改，可以通过修改 namespace 的方式，让新老代码使用不同的缓存结果。
Package: tachi-local
Tachi-Local DetailsTachi-Local DetailsAboutUsageOptionsInstallationpipManual pipPyInstallerZipappManual runMakefileAboutTachiyomilocal mangadetails.jsoncreator.UsingBaka-Updates Manga.Requires Python >= 3.7UsageYou can either directly use a Mangaupdates series link/id, or search using the script.The script will scrape the website and generate thedetails.jsonfor you.tachi-local <id>
tachi-local https://www.mangaupdates.com/series.html?id=<id>
tachi-local -s <title>OptionsYou can see all the options in --help.Main commands:
  using a link or id
  using -s or --search

Search options:
  -a/--auto-first-result: automatically select the first search result
  -m/--max-search-results: maximum search results to show

Options:
  -h/--help and --version
  -k/--keep-status-values: keep the "_status values" entry in the json
  -o/--output: output filenameInstallationYou can use any of the following methods:pipThis is the easiest way.Run the following command:pip install tachi-localNowtachi-localshould be in a location in your PATH and available in your command-line.So you can just run it:tachi-local --helpIt can be uninstalled with this command:pip uninstall tachi-localAnd updated with:pip install -U tachi-local(This method downloads the program fromPyPI)Manual pipYou can download the source and run this command in the project's root directory:pip install .Thentachi-localwill be available in your command-line.PyInstallerYou can download an .exe file created usingPyInstallerfrom thereleasessection.You can place the .exe in a location in your environment PATH so you can run it from anywhere.ZipappYou can get a python zipped executable file from thereleasessection. (file namedtachi-local)You can run it like a normal executable:./tachi-localYou can use this on Windows as well, but it cannot be executed like an exe.You can run it like this:python tachi-localManual runYou can download the source and run the code:python tachi_localMakefileThe makefile is used to automate some tasks.The targets are:make allcreates the zipapp.make get-versionprints the program's version.make distcreates s-dist and b-dist (pure python wheel).make uploaduploads to PyPI.make pyi-speccreates the .spec file for PyInstaller. (needed once)make pyi-execreates a one-file executable using the .spec file.make cleancleans up pycache and the build. (there are separate more specific targets for cleaning as well)pyi_create_version_info.pyis ran withmake pyi-exeand createspyi_win_version_info.pyfrompyi_win_version_info.templatewhich is used by PyInstaller to make the Windows executable's metadata.
Package: tachydownloader
TachyonA multithread downloader created after facing the hardships of downloading with bandwidth throttling.InstallationTo install tachyon you need to have python3. If you are on a MacOS based device, you can use homebrew in your terminal:$brewinstallpython3Then you can use pip to install the python file:# Note: I used the name 'tachydownloader' since the name 'tachyon' is taken.$pipinstalltachydownloaderUsageTo use tachyon, you should be able to run the following from the terminal:$tachyon[DOWNLOAD_URL]Or if you would like to add a filename:$tachyon-n[SAVE_AS_NAME][DOWNLOAD_URL]More InfoFor more details and dealing with errors, please visit theGitHub pagefor this project.LicenseThis software is licensed under the MIT License. It allows you to do nearly anything you want with it, however please do check the LICENSE text file for more details.WRITTEN IN PYTHON
Package: tacimeicalc
Generates phone-related data including IMSI, IMEI, ICCID, MAC address, and phone numberpip install tacimeicalcTested against Windows / Python 3.11 / AnacondaGeneratesphone-relateddataincludingIMSI,IMEI,ICCID,MACaddress,andphonenumber.Args:tac(str):TypeAllocationCode.mcc_number(int):MobileCountryCodenumber.mnc_number(int):MobileNetworkCodenumber.mac_prefix(str):MACaddressprefix.line_country(int):Linecountrycode.phonenumber(str):Phonenumber.Returns:dict:Adictionarycontainingphone-relateddata.fromtacimeicalcimportcalculate_phone_dataphonedata=calculate_phone_data(tac='35440811',mcc_number=724,mnc_number=11,mac_prefix='00:0A:00',line_country=55,phonenumber='82984743677')print(phonedata)# {'imsi': '724118298474367', 'imei': '354408113368770', 'iccid': '89550000118298474360', 'macaddress': '00:0A:00:89:83:3A', 'phone_number': '5582984743677'}
Package: tacitpy
TacitPyTacit Python programming.Examplefromtacitimport*add5=add(5)print('6 + 5 =',add5(6))#=> 11@Curry("int -> int -> float")deff(x,y):return(6.5+x)*y# orf=Curry(lambdax,y:(6+x)*y)a=(f(3)*add(2))(5)b=f(3,2+5)print('a == b  #=>',a==b)#=> true
Package: tacitus-notes
tacitus-notesPublius Cornelius Tacituswas a Roman
historian and politician. And quite recently, he started writing notes on our git
repositories.the dreamWalk through git log, up to last tag or target commit, and collect each commit
message in a markdown format:prettify it,replace ticket numbers with urlsprint on consoleshellscript versiongitdescribe--tags--abbrev=0gitlog$(gitdescribe--tags--abbrev=0)..HEAD--onelinepython versionFirst, install the tiny script:$pipinstalltacitus-notesThen, run this command in your project directory and see what happens:$tacitus-notesYou can use--firstand--lastarguments to define ranges$tacitus-notes--first=<commit_hash>--last=<commit_hash>BSD 2-Clause LicenseCopyright (c) 2021, Florin Ciurcanu
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.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: tacklepy
tacklepy module, version 1.0.1, is specifically designed to simplify the process of data preparation!DataImputeris a Python module designed to handle missing values in
datasets by predicting and imputing those missing values. It provides a
convenient and user-friendly interface for automating the process of
handling missing data and enhancing the completeness of datasets.This module offers various functionalities for imputing numerical and
categorical columns separately. It employs machine learning algorithms
such as HistGradientBoosting, XGBoost, and CatBoost to predict missing
values based on highly correlated features. The choice of the algorithm
for predicting NaNs is customizable, allowing users to select the most
suitable approach for their specific needs.One of the key features of the DataImputer module is its ability to
handle outliers in the data before performing imputation. By identifying
and addressing outliers, the module ensures more accurate imputation results.DataImputer supports a wide range of tasks, including binary classification,
multi-class classification, and regression. The type of column being imputed
determines the specific task performed. The module provides options to exclude
specific columns from the imputation process, control verbosity to receive
informative output during execution, and define the size of the training set
for the prediction models.Installation:$ pip install tacklepy$ pip install --upgrade tacklepyDependenciesDataImputer-code requires:Python (_version_ >= 3.6)Pandas (_version_ >=  2.0.2)Numpy (_version_ >=  1.23.5)XGBoost (_version_ >=  1.7.5)CatBoost (_version_ >=  1.2)Scikit-learn (_version_ >=  1.2.2)Scipy (_version_ >=  1.10.1)DevelopmentAt TacklePy, we value diversity and inclusivity in our community of
contributors. Whether you're a seasoned developer or just starting out,
we welcome you to join us in building a more helpful and effective
platform. Our Development Guide provides comprehensive information on
how you can contribute to our project through code, documentation,
testing, and more. Take a look and see how you can get involved!Important linksOfficial source code
repo:https://github.com/NikitaRomanov-ds/tacklepyIssue
tracker:https://github.com/NikitaRomanov-ds/tacklepy/issuesSource codeYou can check the latest sources with the command:git clonehttps://github.com/NikitaRomanov-ds/tacklepy.gitSubmitting a Pull RequestBefore opening a Pull Request, have a look at the full Contributing page
to make sure your code complies with our
guidelines:https://scikit-learn.org/stable/developers/index.htmlCommunicationAuthor email:xorvat84@icloud.comAuthor profile:https://www.linkedin.com/in/nikita-romanov-766055174/CitationIf you use PyChatAi in a media/research publication, we would appreciate
citations to the following: paper/profile/website/etc.
Package: tacks
Tacks is in development.Project Goals:One tool for one job: pin requirements to plain requirements.txt files.Don't require changes to existing tools or workflows.Output files compatible with standardpip install.Manage pinning from the CLI. Add/remove dependencies while preserving comments and whitespace.Integrate with task runners: Django, Flask, doit, Invoke, or user-defined.Eject at any time. To stop using Tacks, just delete it.Support Python 3.6+. Eventually expand to 2.7 and 3.5+.
Package: tacl
tacl is a tool for performing basic text analysis on the texts
available from theChinese Buddhist Electronic Text Association(CBETA). It is largely generic, however, and can operate with minor
modifications on other corpora.The code is developed athttps://github.com/ajenhl/tacl/and the
documentation is available athttp://tacl.readthedocs.io/en/latest/.InstallationUsingPython 3(minimum version 3.5), either runpip install taclor download the code manually and runpython setup.py install. The dependencies are installed automatically when tacl is
installed withpip. Note however that on Windows (and perhaps Mac
OS X) it is very likely that the dependencies that have non-Python
components will not build due to a missing compiler. In such a case,
follow the instructions athttps://github.com/ajenhl/tacl/wiki/InstallationUsageRuntacl-hfor a listing of available subcommands, andtacl <subcommand>-hfor help on a specific subcommand.
Package: tacl-catalogue-manager
This package provides a library and script to merge multiple lists of
TACL works together in a specified order, and output one or more
catalogue files using supplied labels.The merging process applies the name of the first file to list a work
to that work; all subsequent names for that work are ignored. This
allows for different categorisations of works to be put in a priority
order.The process of creating catalogue files makes use of mappings between
the filenames of the work lists and labels to be used in the
catalogue. Multiple filenames may map onto a single label. The order
of the labels in the mapping is maintained in the catalogue file.UsageRuntcm-hfor help on the command and the files used.