Saravanan666/pypi-org huggingface dataset:
Package: catalyst-rl
Accelerated RLPyTorch framework for RL research.
It was developed with a focus on reproducibility,
fast experimentation and code/ideas reusing.
Being able to research/develop something new,
rather than write another regular train loop.Break the cycle - use the Catalyst!Part ofPyTorch Ecosystem. Part ofCatalyst Ecosystem. Projectmanifest.InstallationCommon installation:pipinstall-Ucatalyst-rlCatalyst.RL is compatible with: Python 3.6+. PyTorch 1.0.0+.Getting startedFor Catalyst.RL introduction, please followOpenAI Gym example.Docs and examplesDemo with minimal examplesfor CV, NLP, RecSys and GANsDetailedclassification tutorialAdvancedsegmentation tutorialComprehensiveclassification pipelineBinary and semanticsegmentation pipelineAPI documentation and an overview of the library can be found here.In theexamples folderof the repository, you can find advanced tutorials and Catalyst best practices.InfosTo learn more about Catalyst internals and to be aware of the most important features, you can readCatalyst-info– our blog where we regularly write facts about the framework.We also superviseAwesome Catalyst list– Catalyst-powered projects, tutorials and talks.Feel free to make a PR with your project to the list. And don't forget to check out current list, there are many interesting projects.ReleasesWe deploy a major release once a month with a name likeYY.MM.And micro-releases with framework improvements during a month in the formatYY.MM.#.You can view the changelog on theGitHub Releasespage.Current version:OverviewCatalyst.RL helps you write compact
but full-featured RL pipelines in a few lines of code.
You get a training loop with metrics, early-stopping, model checkpointing
and other features without the boilerplate.FeaturesUniversal train/inference loop.Configuration files for model/data hyperparameters.Reproducibility – all source code and environment variables will be saved.Callbacks – reusable train/inference pipeline parts.Training stages support.Easy customization.PyTorch best practices (SWA, AdamW, Ranger optimizer, OneCycle, FP16 and more).StructureRL– scalable Reinforcement Learning,
all popular model-free algorithms implementations and their improvements
with distributed training support.contrib- additional modules contributed by Catalyst users.utils- different useful utils for Deep Learning research.Contribution guideWe appreciate all contributions.
If you are planning to contribute back bug-fixes,
please do so without any further discussion.
If you plan to contribute new features, utility functions or extensions,
please first open an issue and discuss the feature with us.Please see thecontribution guidefor more information.By participating in this project, you agree to abide by itsCode of Conduct.LicenseThis project is licensed under the Apache License, Version 2.0 see theLICENSEfile for detailsCitationPlease use this bibtex if you want to cite this repository in your publications:@misc{catalyst,
    author = {Kolesnikov, Sergey},
    title = {Accelerated RL.},
    year = {2018},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/catalyst-team/catalyst-rl}},
}
Package: catan
catan-----Package catan provides models for representing and manipulating a game of catanBoard coordinates must be specified as described in module [`hexgrid`](https://github.com/rosshamish/hexgrid).`.catan` files will be written to the working directory by class Game (see [`catanlog`](https://github.com/rosshamish/catanlog)).class Game also supports undo and redo, which is useful for building GUIs.Supports Python 3. Might work in Python 2.> Author: Ross Anderson ([rosshamish](https://github.com/rosshamish))### Installation```pip install catan```### Usage```import catan.boardimport catan.gameimport catan.tradingplayers = [Player(1, 'ross', 'red'),Player(2, 'josh', 'blue'),Player(3, 'yuri', 'green'),Player(4, 'zach', 'orange')]board = catan.board.Board()game = catan.game.Game(board=board)game.start(players=players)print(game.get_cur_player())  # -> ross (red)game.buy_settlement(0x37)game.buy_road(0x37)game.end_turn()...game.roll(6)game.trade(trade=catan.trading.CatanTrade(...))game.undo()game.redo()game.play_knight(...)game.end_turn()...game.end()```See [`catan-spectator`](https://github.com/rosshamish/catan-spectator) for extensive usage.### File Format<!-- remember to update this section in sync with "File Format" in github.com/rosshamish/catan-spectator/README.md -->catan-spectator writes game logs in the `.catan` format described by package [`catanlog`](https://github.com/rosshamish/catanlog).They look like this:```green rolls 6blue buys settlement, builds at (1 NW)orange buys city, builds at (1 SE)red plays dev card: monopoly on ore```### DocumentationMost classes and modules are documented. Read the docstrings! If something is confusing or missing, open an issue.### LicenseGPLv3
Package: catana
___    __   ____   __    _  _    __                                                /\
 / __)  /__\ (_  _) /__\  ( \( )  /__\       ,--------------------------------------/ vvvvvvvvvvv\
( (__  /(__)\  )(  /(__)\  )  (  /(__)\       "=====================================\^^^^^^^^^^^^'
 \___)(__)(__)(__)(__)(__)(_)\_)(__)(__)                                             \/
                                                                                  Michael Buehlmann
Catalog Analyzer: A library for Spherical Fourier Bessel (SFB) Decomposition
==================================================================================================CatAna is a C++ library and Python package to perform fast spherical Fourier Bessel transformation (Fourier
transformation in spherical coordinates) on discrete, point-like datasets.The code is hosted onGitHub. Please contact the author if you have any
questions, find bugs or have ideas to improve CatAna.Requirementscmake >= 3.2.0GNU Scientific Library (GSL) and headersFFTW3 library and headersCFITSIO library and headersCompiler supporting C++14 (gcc >= 5.0, clang >= 3.4)The library is only being tested on Python 3.5. A compiler supporting OpenMP is recommended to take advantage of the
speedup from parallelization.For the following steps make sure that yourCCandCXXvariables are set to the correct compiler and thatpythonis the correct python executable. Using a virtual environment is recommended.InstallationpipinstallcatanaDocumentationDocumentation can be found underhttps://michaelbuehlmann.github.io/CatAna/The code is hosted onGitHub
Package: catanatron-gym
Catanatron GymFor reinforcement learning purposes, we provide an Open AI Gym environment. To use:pip install catanatron_gymMake your training loop, ensuring to respectenv.get_valid_actions().importrandomimportgymenv=gym.make("catanatron_gym:catanatron-v0")observation=env.reset()for_inrange(1000):action=random.choice(env.get_valid_actions())# your agent here (this takes random actions)observation,reward,done,info=env.step(action)ifdone:observation=env.reset()env.close()Foractiondocumentation seehere.Forobservationdocumentation seehere.You can accessenv.game.stateand build your own "observation" (features) vector as well.Stable-Baselines3 ExampleCatanatron works well with SB3, and better with the Maskable models of theSB3 Contribrepo. Here a small example of how it may work.importgymimportnumpyasnpfromsb3_contrib.common.maskable.policiesimportMaskableActorCriticPolicyfromsb3_contrib.common.wrappersimportActionMaskerfromsb3_contrib.ppo_maskimportMaskablePPOdefmask_fn(env)->np.ndarray:valid_actions=env.get_valid_actions()mask=np.zeros(env.action_space.n,dtype=np.float32)mask[valid_actions]=1returnnp.array([bool(i)foriinmask])# Init Environment and Modelenv=gym.make("catanatron_gym:catanatron-v0")env=ActionMasker(env,mask_fn)# Wrap to enable maskingmodel=MaskablePPO(MaskableActorCriticPolicy,env,verbose=1)# Trainmodel.learn(total_timesteps=1_000_000)ConfigurationYou can also configure what map to use, how many vps to win, among other variables in the environment,
with theconfigkeyword argument. See source for details.fromcatanatronimportColorfromcatanatron.players.weighted_randomimportWeightedRandomPlayerdefmy_reward_function(game,p0_color):winning_color=game.winning_color()ifp0_color==winning_color:return100elifwinning_colorisNone:return0else:return-100# 3-player catan on a "Mini" map (7 tiles) until 6 points.env=gym.make("catanatron_gym:catanatron-v0",config={"map_type":"MINI","vps_to_win":6,"enemies":[WeightedRandomPlayer(Color.RED),WeightedRandomPlayer(Color.ORANGE)],"reward_function":my_reward_function,"representation":"mixed",},)
Package: catapi.py
A python wrapper for TheCatAPI.comKey FeaturesAsynchronous: Perfect for discord botsInstallingPython 3.5.3 or higher is REQUIRED.To install the library through pippipinstallcatapi.pyExample usagecatapi.py is written asynchronously, which requires using asyncio. While this is convenient when running a discord bot, it requires a little more setup in a script.importasyncioimportcatapi# Create the event loop where the code executesloop=asyncio.new_event_loop()# Initialize the apiapi=catapi.CatApi(api_key="YOUR_API_KEY_HERE")defrun_coro(coroutine):returnloop.run_until_complete(coroutine)results=run_coro(api.search(limit=1))print(results[0].url)
Package: catapult
Catapult providesTAPoutput for Python
unittest test suites.Currently it supports theTAP(12),TAP-Y,
andTAP-Jformats. Seecatapult/tests/run.pyfor an example of how to use catapult in your test runner.Nose pluginCatapult also provides a plugin fornose. After installing,
use it like this:nosetests --with-catapult --catapult-format=tap-jwhere the format can be one oftap,tap-j(default), ortap-yInstallingInstall from PyPI with pip:pip install catapult
Package: catasta
Catasta: Streamlined Model ExperimentationCatasta is a Python library designed to simplify and accelerate the process of machine learning model experimentation. It encapsulates the complexities of model training and evaluation, offering researchers and developers a straightforward pipeline for rapid model assessment with minimal setup required.Note: Catasta only supports regression and classification at the moment.Important: Catasta is subject of change until a major version is launched.Key featuresCatasta is a very simple package, containing only five modules, each one with an specific purpose.Themodelsmodule houses a variety of machine learning models.Thedatasetsmodule provides an easy way to import the data contained in directories, being also able to modify the data shape in an easy way.Thetransformationsmodule lets you apply transformations to the data when its loaded to a dataset.Thescaffoldsmodule is where models and datasets are integrated for training. Scaffolds handle training and evaluation.Thearchwaysmodule takes a trained model and handles the inference task.InstallationInstall via pipCatasta is available as a PyPi package:pipinstallcatastaInstall from sourceClone the repositorygitclonehttps://github.com/vistormu/catastaand install the dependenciespipinstall-rrequirements.txtDocumentationWork in progress
Package: catastro-finder
Catastro FinderUnofficial Catastro Finder. No API keys requiredInstallationpipinstallcatastro-finderUsagefromcatastro_finderimportCatastroFindercatastro=CatastroFinder()Get provincesprovincias=catastro.get_provincias()# Select oneselected_provincia=provincias[30]Get municipalitiesmunicipios=catastro.get_municipios(selected_provincia['Codigo'])# Select oneselected_municipio=municipios[68]Get streets candidatesvia_result=catastro.get_vias(selected_provincia['Codigo'],selected_municipio['Codigo'],"JACINTO")[0]Search a property# Choose property numbervia_numero=2inmueble_results=catastro.search_inmueble(via_result,via_numero,selected_provincia,selected_municipio)
Package: ca-taxes
п»ї# California Taxes Django AppDjango based app provides an easy way to get tax rate for city and county in California, US.
It provides Data ModelCATaxand management command for extracting state data.InstallationInstallca-taxes:pip install ca-taxesAddca-taxestoINSTALLED_APPSin Django settings:INSTALLED_APPS = (
  # ...
  'ca_taxes',
  # ...
)Run Django migrations:python manage.py migrateImport CA taxes data fromCalifornia State Board of Equalization.python manage.py cataxesUsageCATaxManager.lookup_tax_rate('Los Angeles', self.test_county)
Package: catbars
Simple bars, four featuresIntroductionCatbars is a Python library for makinghorizontalbar charts.Built on top of Matplotlib (barh), Catbars enables programmers to
visualize efficientlylabelled observations which can be
numerically ordered.As a bit ofdata science logicis embedded in Catbars, observations
can be ordered on demand and colors are inferred from labels. You
can override this automatic behaviour by specifying a dictionary
mapping categories to colors. A default color will be used
for the residual categories.All you have to do is to call theBarsconstructor with the right
keyword arguments (almost everything can be fine-tuned throughkwargs).A special attention has been paid to the layout management. Catbars will
do its best to make room for your data (especially for the long labels
on the leftor on the right) under the constraint of the figure
size (the classic figsize/dpi combination) and the font sizes (data font,
main title font, axis title font).Catbars will automatically render the figure in Jupyter notebooks
(implicit_repr_png_()call). The figure can be saved on disk in
png format (by specifying the keyword argumentfile_nameor by callingprint_png()on the returned object) or in pdf format (print_pdf()).Catbars doesn’t support grouped bar charts and stacked bar charts.LicenseMIT
Package: catbase
CatBaseJSON-based database you were dreaming of!QuickstartfromcatbaseimportCatDBdb=CatDB("example.json")db["test"]="apple"print(db["test"])db.commit()# commit to save changesFeaturesAutocommitingfromcatbaseimportCatDBdb=CatDB("example.json",autocommit=True)db["test"]="apple"# CatDB commits here automatically!print(db["test"])# no commit required!KeyError safetyfromcatbaseimportCatDBdb=CatDB("example.json")# oh no! "test" doesnt exist yet!print(db["test"])# output: NoneCustom KeyError defaultsfromcatbaseimportCatDBdb=CatDB("example.json",none=3)# oh no! "test" doesnt exist yet again!print(db["test"]+1)# output: 4Broken JSON safetyfromcatbaseimportCatDBdb=CatDB("example.json",safe=False)# now, if the example.json is corrupt, db will be empty instead of crashing.# safe is set to True by default.
Package: catbird
Catbirdis an open source paraphrase generation toolkit based on PyTorch.Quick StartRequirements and InstallationThe project is based on PyTorch 1.5+ and Python 3.6+.Install Catbirda. Clone the repository.gitclonehttps://github.com/AfonsoSalgadoSousa/catbird.gitb. Install dependencies.This project uses Poetry as its package manager. There should Make sure you have it installed. For more info checkPoetry's official documentation.
To install dependencies, simply run:poetryinstallDataset PreparationFor now, we only work with theQuora Question Pairs dataset. It is recommended to download and extract the datasets somewhere outside the project directory and symlink the dataset root to$CATBIRD/dataas below. If your folder structure is different, you may need to change the corresponding paths in config files.catbird
├── catbird
├── tools
├── configs
├── data
│   ├── quora
│   │   ├── quora_duplicate_questions.tsvWe use theHuggingFace Datasets libraryto load the datasets.Trainpoetryrunpythontools/train.py${CONFIG_FILE}[optionalarguments]Example:Train T5 on QQP.$pythontools/train.pyconfigs/t5_quora.yamlContributorsAfonso Sousa(afonsousa2806@gmail.com)
Package: catbox
Sandbox is a mechanism which provides a tighly-controlled set of resources
for guest programs to run in. They are used for security and testing purposes.There are many uses for a sandbox in package management:1. In the build process, we dont want packages to modify host operating
system while they are configuring or compiling. We want them to be
constrained in their temporary build directory. Denying the write
operations outside of this directory is most basic application of
a sandbox here.2. Instead of actually doing some operations like changing permission or
ownership of files, we can just log them, and mark in the generated package.
That way we dont need to be a root user in order to build a package with
such properties.3. We can log many build operations, and analyze them to see actual
build dependencies of the package for example.4. We can build package in a temporary directory, but let it think that
in runs in root directory with everything out there is read only mapped
inside. That can greatly simplify build scripts.There are two ways to sandbox a build script within user context without
resorting to special kernel modules:1. We can override functions of glibc with LD_PRELOAD. Since this requires
executing the script inside a new shell, passing Python variables between
builder and scripts is hacky and cumbersome.We can intercept system calls with kernel ptrace interface.We decided to go with the latter way. There is already a good ptrace
sandbox framework for Python, called Subterfugue. Apart from a small
C binding for ptrace call, it is completely written in Python.
Unfortunately dealing with each system call with Python is quite
slow for a build farm. There are over a thousand packages, and
some of them like OpenOffice.org or kdebase takes a huge time to
compile even on high end computers.Thus we wrote catbox, a small sandboxing module for PiSi (the package
manager for Pardus Linux). It is completely written in C, and it wont
provide custom system call hooks or advanced modifications to the
guest environment like Subterfugue.Although, catbox started as a sandboxing module for PiSi, it is now a
more generic sandbox module that can be used generically.Event Hooks:child_initialized(pid): Event hook is called on parent process but
after child is initialized to be traced and before parent notifies
child to continue. Pid of the child process is given as the only
argument. (available in version 1.4+)child_died_unexpectedly(pid): Event hook is called when we got a
signal/event from a child but the child was already dead. Pid of the
child process is given as the only argument. (available in version
1.4+)Dependencies:pcre (OPTIONAL): If enabled path can be defined with regular
expressions. Just append –enable-pcre to the setup.py command.Testify: (https://github.com/Yelp/Testify) Testify is used for
unittests only.
Package: catbridge
CAT Bridge: A Versatile Tool for Multi-Omics AnalysisOverviewWith advancements in sequencing and mass spectrometry technologies, multi-omics data can now be easily acquired for understanding complex biological systems. Nevertheless, substantial challenges remain in determining the association between gene-metabolite pairs  due to the complexity of cellular networks. Here, we introduce CAT Bridge (freely available athttp://catbridge.work), a user-friendly platform for longitudinal multi-omics analysis to efficiently identify transcripts associated with metabolites using time-series omics data. To evaluate the association of gene-metabolite pairs, CAT Bridge incorporated a range of methods harnessing cause-and-effect relationships and similarity computation, many of which are used in omic analyses for the first time. Additionally, CAT Bridge featured an artificial intelligence (AI) assistant to assist users interpreting the assoication results. We applied  CAT Bridge to self-generated (chili pepper) and public (human) time-series transcriptome and metabolome datasets. CAT Bridge successfully identified genes involved in the biosynthesis of capsaicin in Capsicum chinense L. Furthermore, case study results showed that the convergent cross mapping (CCM) method outperforms traditional approaches in longitudinal multi-omics analyses. CAT Bridge simplifies access to various established methods for longitudinal multi-omics analysis, and enabling researchers to swiftly identify associated gene-metabolite pairs for further validation.For more information:Project homepageInstallationPython dependencies can be installed using pip (from the Unix terminal)pip install catbridgeContactThe package is developed and maintained by Bowen Yang (by8@ualberta.ca). Please, reach us for problems, comments or suggestions.
Package: catbuffer
catbufferThis is the Python version of the catbuffer library. It is generated usingcatbuffer-generatorsfrom thecatbufferspecification.The generated code is in Python version 3.7.This library helps serialize and deserialize NEM's Catapult entities in Python applications.The library's main client is (symbol-sdk-core-python). We suggest not using this library directly.Right now only transactions and related objects are generated in sensible manner, support ffor state-related objects will be added in future.Installation & Usagepip installThe python catbuffer package is hosted onPyPI.To install the latest release:pipinstallcatbuffer(you may need to runpipwith root permission:sudo pip install catbuffer)To install a specific version or a snapshot:pipinstallcatbuffer=={version}Example:pip3installcatbuffer==1.0.0.20210413.152059a1
Package: catbuffer-parser
catbuffer parserThe catbuffer library defines the protocol to serialize and deserialize Symbol entities. Code generators from thecatbuffer-generatorsproject can then produce the leanest code necessary to serialize and deserialize those entities.Using catbuffer-generators, developers can generate builder classes for a given set of programming languages. For example, theSymbol SDKsuse the generated code to interact with the entities in binary form before announcing them to the network.Theschemasfolder contains definitions for each entity's data structure. These definitions are always kept up to date and in sync with thecatapult servercode.RequirementsPython >= 3.6InstallationClone thecatbuffer-parserrepository:gitclonehttps://github.com/nemtech/catbuffer-parser(optional) Install lint requirements:pip3install-rlint_requirements.txtUsagepython3-mcatbuffer_parser[OPTIONS]OptionDescriptionDefault-s, --schema TEXTInput CATS file-o, --output TEXTOutput directory_generated-i, --include TEXTSchema root directory./schemas-g, --generator TEXTGenerator to use to produce output files (see theavailable generators).-c, --copyright TEXTFile containing copyright data to use with output files.../HEADER.incExamplesIn order to produce any output file, thecatbuffer-generatorsproject is needed. Please see this project's usage examples.However,catbuffer-parsercan still be used on its own to parse input files and check their validity:gitclone--depth1--branchv1.0.0https://github.com/nemtech/catbuffer-schemas.git
python3-mcatbuffer_parser--schemacatbuffer-schemas/schemas/transfer/transfer.cats--includecatbuffer-schemas/schemas
Package: catcher-modules
Catcher modulesExternalCatchermodules repository.Besides thebuilt-inCatcher supportexternalmodules: as python or any other executable scripts.SeeCatcherdocumentation on installation catcher with catcher-modules.UsageYou can either write your own module in python or as external shell script. Both ways are covered
in Catcher documentation forexternalmodules.Read thedocsfor existing modules usage info:catcher_modulesContributionIf you believe your external python module can be useful for other people you can create a pull request here.
You can find quick support in the telegram channel.Contributors:Many thanks toEkaterina Belovafor core & modules contribution.Additional dependencieslibclntsh.dylibis required fororacle. Read morehere.unixodbc-devanddriverare required formssqlWebdriveris required for seleniumWebdriverbundlefor your language (except python) is required for selenium.