Saravanan666/pypi-org huggingface dataset:
Package: histlabapi
History as Data ScienceHistory Lab APITheHistory Labfocuses on digitizing historical documents and turning them into a format more amenable to the tools of modern data analysis. As part of this, the History Lab has compiled a database of more than 3 million declassified historical documents.Traversing any large database of this sort can be tedious though.histlabapiis a Python library that aims to solve this, making it easier for users to access data from the History Lab's database by wrapping around the History Lab's API.InstallationInstallation is quite straightforward with pip. This package is only compatible with Python 3.9+ due to its usage of therequestsdependency and its reliance onsphinxto generate its documentation.$pipinstallhistlabapiUsageBefore getting to extracting documents left and right, its important to get some bearing on how the History Lab stores and structures its various documents. As such, I've compiled a quick guide where one can look up the various collections and fields that you can access through this APIhere!Once that's settled, one can use this package's various functions to extract information in all kinds of ways:Anoverviewof all the collections currently available in the APIListingall the entities of a certain type that appear across all collectionsSearching and extracting documents bytext,entity,dateordocument IDDocumentationFull documentation can be accessed atRead the DocsSupportFeel free to contact me atdg3279@columbia.eduif you have any questions and/or want to contribute!Licensehistlabapiwas created by Derrick Gozal. It is licensed under the terms of the MIT license.Creditshistlabapiwas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Also much thanks to Professor Raymond Hicks and the rest of the History Lab team for all the support in building up this package.
Package: histlite
histliteSee documentation onReadTheDocs.histliteis a histogram calculation and plotting library that tries to be
"lite" on data structures but rich in statistics and visualization features.
So far, development has taken place during my (Mike Richman) time as a graduate
student and post-doctoral researcher in the field of particle astrophysics —
specifically, working with the IceCube Neutrino Observatory.  Histlite is
intended both to facilitate high-paced exploratory data analysis as well as to
serve as a building block for potentially very complex maximum likelihood data
analysis implementations.The core design considerations are:It must be trivial to work with and interchange between 1D, 2D, or ND histograms.It should be as simple as possible to perform bin-wise arithmetic
operations on one or more histograms; to perform sums, integrals, etc. and
thus normalizations along one or more axes simultaneously; and to perform
spline or user-defined functional fitsIt should be as simple as possible to achieve publication-quality plots.The primary histogramming functionality consists of a thin wrapper aroundnumpy.histogramdd.  Statistical tools leveragescipybut include
custom solutions for some use cases.  (Importantly, error propagation is
currently handled manually but may be migrated to theuncertaintiespackage in the future.)  Plotting is done usingmatplotlib.
Package: hist-loss
Histogram Based LossesThis library contains implementations of some histogram-based loss functions:Earth Mover Distrance LossHistgramm Loss (paper,original code)Inverse Histogram Loss (our impovements)Bidirectinal Histogramm Loss (our impovements)Continuous Histogram Loss (paper)Also there are implementations of another losses to compare:Negative Log-LikelihoodBinomial Deviance loss (paper)InstallationInstallation from sourceThe instalation directly from this repository:https://github.com/stat-ml/hist-loss.git
cd histloss
python setup.py installPip Installationpip install hist-lossExample of usagecriterion=HistogramLoss()positive=torch.sigmoid(torch.randn(10,requires_grad=True))negative=torch.sigmoid(torch.randn(10,requires_grad=True))loss=criterion(positive,negative)loss.backward()
Package: histoboxplot
HistoBoxPlothistoboxplot is a Python package for creating combined histogram and boxplot visualizations. This tool is particularly useful for exploratory data analysis and presenting data distributions clearly and concisely.InstallationTo install histoboxplot, run the following command:pip install histoboxplotUsageHere's a simple example of how to use HistoBoxPlot:importpandasaspdfromhistoboxplotimporthistoboxplot# Sample DataFramedata=pd.DataFrame({'feature':[yourdatahere]})# Create the plothistoboxplot(data,'feature')RequirementsPython3.6orhighermatplotlibseabornContributingContributionstoHistoBoxPlotarewelcome!Pleasereadthecontributingguidelines.LicenseThisprojectislicensedundertheApacheLicense.ContactIfyouhaveanyquestionsorfeedback,pleasecontactmeatIfyouhaveanyquestionsorfeedback,pleasecontactmeatatugharajohn@gmail.com.
Package: histodata
TODOHistodataThis repository is a aggregation of pytorch datasets for loading histology datasets.installationpip install --upgrade histodataUsageTodo for each dataset a own list.Including:Describtion of the datasetHow to get the datasetDokumentation of the interfaceExample usage of the interfacefrom histodata.datasets import mai, midog, bach, pcam

dataset = mai.mai_patches('path_to_datafolder',
                               transformation=None,
                               subset='train',
                              )
Package: histograms
Python package to easily make histograms from multi-indexed dataframes.How do I install this package?As usual, just download it using pip:pipinstallhistogramsTests CoverageSince some software handling coverages sometime get slightly different results, here’s three of them:Usage examplesThe library offers two main methods:histogram, for plotting a single histogram, andhistograms, for plotting
a number of histograms in parallel fashion.Histogramsfromhistogramsimporthistogramsdf=pd.read_csv("tests/test_case.csv",index_col=0)histograms(df,["dataset","resource","model"])This will output the following images (just a few examples reported here):
Package: histogramy
Histogramy=============================================================================Histogramy is a CUI program to analyze 1-dimensional data.It draw a histogram with specified data and it also can draw the fitting curveestimated by a Gaussian Mixture Model probability distribution.![Screenshot](https://raw.github.com/lambdalisue/Histogramy/master/static/screenshot.png)Requirements------------------------------------------------------------------------------   [Python][]-   [numpy][]-   [matplotlib][]-   [scikit-learn][][Python]: http://www.python.org/[numpy]: http://www.numpy.org/[matplotlib]: http://matplotlib.org/[scikit-learn]: http://scikit-learn.org/dev/index.htmlInstall-----------------------------------------------------------------------------1.  You have to install [Python][]. Follow the instruction athttp://www.python.org/getit/2.  You also have to instal [numpy][], and [matplotlib][].Follow the instructions below1.  numpy: http://docs.scipy.org/doc/numpy/user/install.html2.  matplotlib: http://matplotlib.org/users/installing.html3.  Now, you can install Histogramy with [pip][] or [easy_install][].[scikit-learn][] will be installed automatically when you installHistogramy1.  Install [pip][] or [easy_install][], follow the instrcutions below-   pip: http://www.pip-installer.org/en/latest/installing.html-   easy_install: http://pypi.python.org/pypi/setuptools2.  Install Histogramy with the following command in Terminal (CommandPrompt)~~~pip install histogramy~~~or~~~easy_install histogramy~~~[pip]: http://www.pip-installer.org/[easy_install]: http://pypi.python.org/pypi/setuptoolsUsage-----------------------------------------------------------------------------usage: histogramy [-h] [-b BINS] [-c N] [-C N] [--base BASE] [--auto-base][--min-threshold MIN] [--max-threshold MAX][--covariance-type TYPE] [--min-covar MIN_COVAR][--delimiter DELIMITER] [--encoding ENCODING] [--demo][filenames [filenames ...]] {histogram,fit,plot} ...positional arguments:filenames{histogram,fit,plot}histogram           Show histogram datafit                 Show fitting dataplot                Create graph by matplotliboptional arguments:-h, --help            show this help message and exit-b BINS, --bins BINS  It defines the number of equal-width bins.-c N, --column N      A number of column in data file used for analysis-C N, --classifiers NThe maximum number classifiers to simulate the fitting--base BASE           Base value to modulate the data--auto-base           Automatically find the base value to modulate the data--min-threshold MIN   Minimum threshold. Value smaller than this will beignored--max-threshold MAX   Maximum threshold. Value grater than this will beignored--covariance-type TYPEType of covariance. Default is "diag"--min-covar MIN_COVARMinimum value of covariance--delimiter DELIMITERDelimiter used to parse the data file--encoding ENCODING   Encoding used to open the data file--demo                Use demo data to analysis
Package: histomics-detect
histomics_detectis a Python package for the building and evaluating cell detection
models. It provides data loading, data augmentation, performance metrics, model building,
visualization, and other utility functions based on Keras and TensorFlow2.To get started, clone to your local system and install in developer mode:$pip install -e ./histomics_detectTo run in Docker, mount the folder containing the cloned repository and then pip install
inside the running container.See /histomics_detect/example/ for a Jupyter notebook demonstrating how to build a FasterRCNN
model using histomics_detect.
Package: histo-patch
Overviewhisto_patch is a python library to extract patches from annotated region in WSI files (Hamamatsu .ndpi or Aperio .svs).
Hamamatsu .ndpa and QuPath .geojson annotation files are supported.InstallationThe package can be installed withpip:$pipinstallhisto-patchTo run histo_patch, simply run below from console:$histopatch[something]Usage:Usage: histopatch [OPTIONS] PATH_TO_WSI PATH_TO_SAVE_DIRECTORY

Options:
-a, --annotation_type [ndpa|qupath]
                                 file type of annotation (ndpa or qupath
                                 (GeoJSON(Pretty JSON)))
-s, --annotation_shape [all|line|area]
                                 annotation shape (all, line, area)
-c, --color TEXT                used colors (white,black,red,green,blue,cyan
                                 ,magenta,yellow) in annotation for ndpa or (
                                 None,Tumor,Stroma,Immune_cells,Necrosis,Othe
                                 r,Region,Ignore,Positive,Negative) for
                                 QuPath
--line_as_area                  line annotation in ndpa file is treated as
                                 closed area
--src_size FLOAT                patch size in the original WSI
-m, --micrometer                specify src_size in micrometer
                                 (default:pixels)
--patch_size INTEGER            output patch size
--num_patch INTEGER             number of patches for each annotation shape
--nparent INTEGER               number of parent directories kept in the
                                 output
--help                          Show this message and exit.PrerequisitesPython version 3.6 or newer.tifffile >=2022.5.4numpy >=1.20.3tripy >=1.0.0pyclipper >=1.3.0opencv-python >= 4.6.0zarr >=2.11.3magecodecs >=2022.2.22click >=8.1.3Recommended EnvironmentOSLinuxMac
Package: histopy
# HistopyBASH-style history for the Python3 interactive interpreter.Daniel W. Paley, 2018.
Contact:dwpaley@gmail.comGithub:https://github.com/dwpaley/histopyQuickstart:` >>> import histopy as hp >>> hp.history_full()     # like $ history >>> hp.history()          # history of current session >>> hp.recall(n)          # like $ !n >>>hp.find('foo')# print lines matching 'foo' `Known issues:
* recall_range(n1, n2) doesn’t attempt to handle any exceptions. Would be nice
to prompt e.g. “recall_range stopped with exception … on line … Continue
on line …?”
Package: histore
History Store(HISTORE) is a Pyhton package for maintaining snapshots of evolving data sets. This package provides an implementation of the core functionality that was implemented in theXML Archiver (XArch). The package is a lightweight implementation that is intended for maintaining data set snapshots that are represented as pandas data frames.HISTOREis based on a nested merge approach that efficiently stores multiple dataset snapshots in a compact archive[Buneman, Khanna, Tajima, Tan. 2004]. The library allows one to create new archives, to merge new data set snapshots into an existing archive, and to retrieve data set snapshots from the archive.InstallationInstallhistorefrom thePython Package Index (PyPI)usingpipwith:pipinstallhistoreExamplesHISTOREmaintains data set versions (snapshots) in an archive. A separate archive is created for each data set. The package currently provides two different types of archive: a volatile archive that maintains all data set snapshots in main-memory and a persistent archive that writes data set snapshots to disk.Example using Volatile ArchiveStart by creating a new archive. For each archive, a optional primary key (list of column names) can be specified. If a primary key is given, the values in the key attributes are used as row keys when data set snapshots are merged into the archive. If no primary key is specified the row index of the data frame is used to match rows during the merge phase.For archives that have a primary key, the initial dataset snapshot (or at least the dataset schema) needs to be given when creating the archive.# Create a new archive that merges snapshots# based on a primary key attributeimporthistoreashsimportpandasaspd# First versiondf=pd.DataFrame(data=[['Alice',32],['Bob',45],['Claire',27],['Dave',23]],columns=['Name','Age'])archive=hs.Archive(doc=df,primary_key='Name',descriptor=hs.Descriptor('First snapshot'))Add the first two data set versions to the archive:# Second version: Change age for Alice and Bobdf=pd.DataFrame(data=[['Alice',33],['Bob',44],['Claire',27],['Dave',23]],columns=['Name','Age'])archive.commit(df,descriptor=hs.Descriptor('Alice is 33 and Bob 44'))List information about all snapshots in the archive. This also shows how to use the checkout method to retrieve a particular data set version:# Print all data frame versionsforsinarchive.snapshots():df=archive.checkout(s.version)print('({}){}\n'.format(s.version,s.description))print(df)print()The result should look like this:(0)First snapshot

     Name  Age
0   Alice   32
1     Bob   45
2  Claire   27
3    Dave   23(1)Alice is 33 and Bob 44

     Name  Age
0   Alice   33
1     Bob   44
2  Claire   27
3    Dave   23Example using Persistent ArchiveTo create persistent archive that maintains all data on disk use thePersistentArchiveclass:archive=hs.PersistentArchive(basedir='path/to/archive/dir',create=True,doc=df,primary_key=['Name'])The persistent archive maintains the data set snapshots in two files that are created in the directory that is given as thebasedirargument.For more examples see the notebooks in theexamples folder.
Package: historical-robots-txt-parser
Historical Robots.txt ParserThis is a small Python package that parses the historical robots.txt files from the Internet Archive's Wayback Machine and coerces the data into a CSV file for tracking addition and removal ofAllowandDisallowrules by timestamp of addition, path, user-agent, rule type (optional). It's a fairly narrow use case but may be helpful to researchers or journalists.It also includes a parser to coerce a robots.txt file into a dictionary.RequirementsPython 3.7 or laterInstallationInstall with Pythonpip3 install historical-robots-txt-parserInstall with GitThis package was developed usingPoetry, which greatly simplifies the experience of dealing with dependencies and everything. Using Poetry is strongly recommended.git clone https://github.com/alexlitel/historical-robots-txt-parser
cd historical-robots-txt-parser
poetry installThere is arequirements.txtfile included here, so you can also usepip3 install -r requirements.txtif you don't want to use Poetry.UsageThere are two functions included in the package:parse_robots_txtandhistorical_scraper.historical_scraperscrapes the historical files for a domain from the Wayback Machine and exports to a CSV.parse_robots_txtmakes a request to a robots.txt file, parses and coerces it to a dictionary. If you clone the repo, there's a fileapp.pywhich takes command line arguments for domains to scrape.historical_scraperUsagefrom historical_robots import historical_scraper

historical_scraper('website.com', 'website.csv', <optional arguments>)Parametersparametertyperequireddefault valuedescriptiondomainstringtrueThe domain to scrape records from. Only should be hostname withoutwww.file_pathstringtruePath of CSV file to export toaccept_allowbooleanfalseFalseWhether to allow parser to parseAllowrules and include those in dataset. Adds a new column to CSV forRuleto noteDisalloworAllowrule. By default, function only checksDisallowrules.skip_scrape_intervalbooleanfalseFalseWhether to skip the default sleep interval between each historical robots.txt request.Truevalue may cause errors.sleep_intervalnumberfalse0.05Number of seconds to sleep in between robots.txt requests.  Ignored ifskip_scrape_intervalisTrueparamsdictionaryfalse{}Key value pairs representingvalid URL params for the Wayback CDX APIparse_robots_txtUsagefrom historical_robots import parse_robots_text

parse_robots_txt('https://www.website.com/robots.txt', False)Parametersparametertyperequireddefault valuedescriptionURLstringtrueThe URL to request robots.txt file from.accept_allowbooleanfalseFalseWhether to parseAllowrules. By default, function only checksDisallowrules.
Package: historical-timelines
historical-timelinesPython package for creating timelines of historical events.Overviewhistorical-timelines is a python package for creating nice looking timelines, specifically with historical data in mind. historical-timelines usesbokehto create images.InstallInstall withpip install historical_timelinesQuick startFirst, you'll need to import theHistoricalTimelineobject.fromhistorical_timelinesimportHistoricalTimelineThen, you need to populate it. Here's how to populate and display a random timeline:fromhistorical_timelinesimportHistoricalTimelinetimeline=HistoricalTimeline("Random Timeline")timeline.populate_random_timeline()timeline.render_timeline("timeline.html")This will produce something that looks like this:If you have a csv that you want to convert to a timeline, you can do that too. Suppose you have a csv with the pathtimeline.csv, and five columns entitledName,Description,Label,Start, andEnd. It would be imported like this.fromhistorical_timelinesimportHistoricalTimelinetimeline=HistoricalTimeline("Timeline from my csv")timeline_json=HistoricalTimeline.json_from_csv("timeline.csv","Name","Description","Label","Start","End",)timeline.populate_timeline_from_dict(timeline_json)timeline.render_timeline("timeline.html")DocumentationThe documentation can be foundhere.A jupyter tutorial can be foundhere.
Package: historydb
Historydbclient implemented in Python.It implements C++ API with some pythonic additions, such as iterators and helper functions.Also it contains client which can usegeventor threads and handles reconnects and retries.Requireselliptics=2.25.*system package (with Python bindings).To run tests:$ python bootstrap.py
$ bin/buildout
$ bin/nosetestsFor elliptics=2.24.* use v0.3.0
Package: history-exploiter
Lets you selectively manipulate your browsing history in FireFox.View and Delete your browsing history containing certain unwanted wordsView and Delete your history of a particular time periodInstallation$sudopipinstallhistory-exploiterUsageRun the following command in your terminal.$history-exploiter[mode][by][mode] can be:-t or –test : Testing mode (selected history is displayed, no actual
deletion)-d or –delete : Deletion mode (selected history is permanently
deleted)[by] specifies show/delete history on what basis. It ban be:-kw or –keywords : To show/delete history according to some keywords-ts or –timespan : To show/delete history according to a particular
timespanIn case no arguments are passed, follow throught the instructions on
running the script.Example>>history-exploiter-t-kwRunningintestingmode:Enterthelistofkeywordstosearchforinthehistory:movieyoutubeTheseResultsmatchedyourqueries:1.http://123movies.to/2.https://www.youtube.com/watch?v=6vA3H8sQK883.....4.....>>history-exploiter-d-kwRunningindeletionmode:Enterthelistofkeywordstosearchforinthehistory:watchyoutubeDeletinghistory........Done.
Package: historylink
AboutStore an history of model url changea manager to register model to surveya middleware to intercept http404 and redirect to new url if exists.InstallationTo install the latest stable version:pip install -e git+https://github.com/oxys-net/django-historylink.git#egg=django-historylinkYou will need to includehistorylinkin yourINSTALLED_APPS:INSTALLED_APPS = (
    ...
    'historylink',
)You will need to includehistorylinkin yourMIDDLEWARE_CLASSES:MIDDLEWARE_CLASSES = (
    ...
    'historylink.middleware.HistoryLink',
)UsageIn your modelsfrom historylink.manager import manager
manager.register(model)
manager.register([model1, model2])
manager.register([model1, model2], MyModelManager) # where MyModelManager inherit from manager.ModelManagerDjango commandThe command below add HistoryLink object for your existing datas./manage.py historylink_sync
Package: history-manager
hmCommand line history manager for bash (distributed as a python package).AboutHistory manager provides an alternative command line history storage with the ability to select a subset of commands and load it into the current Bash session so theCtrlrsearch is performed on the selected subset. It has anSQLitedatabase under the hood and, besides the executed command line, stores time, working directory, returned code and a unique terminal session identifier. All additional information may be used as a selection criterion.MotivationThere are two main usage scenarios:Recover historyIt is a quite common issue when you need to repeat some actions with a previously developed project but don't remember exact commands you have used for it. History manager provides a way to recover command history related to the specific directory, particular session or both.Synchronize historyThe recovery of a history can be assumed as synchronization between previously existed session and the current one. But it may be also useful to synchronize histories of several simultaneously opened terminal sessions so any executed command can be easily shared. History manager solves this by using the same command selection mechanism as for the history recovery case.