Saravanan666/pypi-org huggingface dataset:
Package: cattledb
# Cattle DB #[![Build Status](https://travis-ci.org/wuttem/cattledb.svg?branch=master)](https://travis-ci.org/wuttem/cattledb)Fast BigTable Time Series Database Implementation## Installation
Recursive Option is needed to build the C Speedups.` git clone--recursivehttps://github.com:wuttem/cattledb.gitpip install ./cattledb `## Run Docker Emulator for Tests on Machine`bash docker run-it-p8080:8080spotify/bigtable-emulator:latestexport BIGTABLE_EMULATOR_HOST=localhost:8080 pytest tests `## Build and Start Tests in docker` docker build .-tcattledb-testdocker run-itcattledb-testbash servicebigtable-serverstart exportBIGTABLE_EMULATOR_HOST="localhost:8080"pytest tests `## Compile python protobuf file`bash # RUN python-mgrpc.tools.protoc--python_out=./cattledb/grpcserver--grpc_python_out=./cattledb/grpcserver--proto_path=./protoscdb.proto # cd to .\cattledb\grpcserver\cdb_pb2_grpc.py # change line import cdb_pb2 as cdb__pb2 # to from . import cdb_pb2 as cdb__pb2 `## Build and Push cattledb docker`bash docker build .-tmths/cattledb:latest docker tag mths/cattledb:latest mths/cattledb:0.1 docker push mths/cattledb `
Package: cattle-grid
cattle_gridcattle_grid is meant to simplify handling authentication in server to
server communication of the Fediverse. cattle_grid checks the HTTP
signatures based on the headers. For this public keys are retrieved
and cached.For installation instructions see thedocumentation.DevelopmentOne can run the pytest tests viapoetryinstall
poetryrunpytestDevelopment with Fediverse pastureIn your Funfedi.dev directory (seeherefor details), runcdfediverse-pasture
dockercompose--filepasture.ymluppasture_verify_actorNow in the cattle grid directory, runpoetryrunpython-mcattle_grid.config--actor_idhttp://cattle_grid/actorto create acattle_grid.tomlfile. Then start the docker containers viadockercomposeupBy openinghttp://localhost:2909/?actor_uri=jskitten@cattle_grid_demo, you should then be able to view the verify actor result. By refreshing the page and inspecting the log files, you can also check that the requests only ran once.Running GUI tests with the pastureStart mastodon accessible through your browsercdfediverse-pasture
dockercompose--filemastodon42.yml--profilenginxupSeeFun Fediverse Developmentfor instructions.Then you can openmastodon42weband lookupjskitten@cattle_grid_demo.
When you send a message to this kitten, it should reply with a meow, e.g.
Package: cattleprod
CattleprodA quick-and-dirty Python wrapper for the Rancher API. Tries do be dynamic in what it does, so that every API action is mapped dynamically into the API without the need to update source code. For a quickstart introduction please see the github repository.The wrapper is far from complete, so YMMV if you try to use it, but I hope it is stable.CHANGELOG0.6.0Date: 2016-06-14Authentication using HTTP basic auth works now (and pretty much everything else which is provided by therequestsmodule)0.5.1Date: 2016-06-075.0.1 release because of download issues with PyPI. No idea why.0.5.0Date: 2016-05-12BREAKING: Different object name (RancherObject->Rod)BREAKING: Different entry point (cattleprod.poke(url))FEATURE: Based onDotMapnow (DotMap github URL)FEATURE: Providingdo_*(data=None)wrappers now for theactions { ... }linksDOC: Updated readme in source repository0.4.0Date: 2015-12-18initial public release
Package: cattqt
A control GUI for Chromecasts written using python3, catt api, pychromecast and PyQt5.Features:Able to cast files, links and playlist urlsControl muliple chromecasts selectable from listGet data in real time and see changes from other devicesSupports device reboot with initial volume settingAutomatically plays files in same directoryPlay/Pause/Stop/Seek/Volume/RebootMulti-platformInstall from PyPi:pip3 install catt pychromecast PyQt5 cattqtRun:catt-qtOptionally specify--reconnect-volumewith range of 0-100:catt-qt--reconnect-volume=25By default, in the event of reconnect, the volume will be set to the volume before disconnectUpdate:pip3 install--no-cache-dir--upgradecattqtScreenshots:
Package: cattrs-env
cattrs-envcattrs-envis an Environment Variable parser/validator which utilizes thecattrslibrary.cattrs-envparses Environment Variables fromos.environand structures them into acattrscompatible dataclass. Providing you with easy and type safe environment variables in your project.Becausecattrs-envgets the Environment Variables fromos.environ, it is fully compatible with any Environment Variable loading library such aspython-dotenv.fromdataclassesimportdataclassfromtypingimportList,Optionalfromcattrs_envimportCattrsEnv@dataclassclassEnv(CattrsEnv):A:intC:List[str]B:Optional[float]=Noneenv=Env.load()env.Aenv.Cenv.BExamplesdataclass exampleimportosfromdataclassesimportdataclassfromtypingimportList,Optionalfromcattrs_envimportCattrsEnv@dataclassclassEnv(CattrsEnv):A:intC:List[str]B:Optional[float]=Noneif__name__=="__main__":os.environ.update({"A":"99","B":"9.9","C":'["a","b","c", 1]',})env=Env.load()print(env)attrs exampleimportosfromtypingimportList,Optionalimportattrsfromcattrs_envimportCattrsEnv@attrs.defineclassConfig:E:strF:Optional[int]=None@attrs.defineclassEnv(CattrsEnv):A:intC:List[str]D:ConfigB:Optional[float]=Noneif__name__=="__main__":os.environ.update({"A":"99","B":"9.9","C":'["a","b","c", 1]',"D":"""{'E':"abcdef"}""",})env=Env.load()python-dotenv examplefromdataclassesimportdataclassfromtypingimportList,Optionalimportdotenvfromcattrs_envimportCattrsEnv@dataclassclassEnv(CattrsEnv):A:intC:List[str]B:Optional[float]=NoneENV_FILE_CONTENTS="""A=1B=99.9C="['foo', 'bar']""""if__name__=="__main__":withopen(".env","w")asenv_file:env_file.write(ENV_FILE_CONTENTS)dotenv.load_dotenv()env=Env.load()print(env)
Package: cattrs-extras
cattrs-extrasThis package contains advanced converter classes forcattrs, a great serialization library built aroundattrs.Key featuresSupport for additional types: Decimal, bool, datetime, date, timedeltaAlternative structuring algorithm capable of handling complex Unions without registering additional hooksHuman-readable exceptions on structuring failureSupport for Tortoise ORM models serialization (including relations)Additional class and Tortoise field for reversed enumerations (serialized to member name instead of value)InstallationDEV=0 PYTHON=python make install  # remove PYTHON to use pyenv
make buildUsagefromenumimportEnumfromdecimalimportDecimalfromdatetimeimportdatetimefromattrimportdataclassfromcattrs_extras.converterimportConverterclassColor(Enum):RED='RED'GREEN='GREEN'@dataclass(kw_only=True)classApple:weight:Decimalcolor:Colorbest_before:datetimesweet:boolconverter=Converter()raw_apple={'weight':'200.5','color':'RED','best_before':'2020-04-02T12:00:00','sweet':'true'}apple=converter.structure(raw_apple,Apple)assertapple==Apple(weight=Decimal('200.5'),color=Color.RED,best_before=datetime(2020,4,2,12,0),sweet=True)raw_apple=converter.unstructure(apple)assertraw_apple=={'weight':'200.5','color':'RED','best_before':1585818000.0,'sweet':True}Tortoise ORMImportant note: Tortoise ORM have chosenpydanticas a serialization library so better to stick with it. However pydantic support is still WIP, you can check current statushere.fromcattrs_extras.tortoise.converterimportTortoiseConverterfromcattrs_extras.tortoise.modelimportModelfromtortoiseimportfields# TODO: ReversedCharEnumField exampleclassAppleModel(Model):id=fields.IntField(pk=True)weight=fields.DecimalField(20,10)color=fields.CharEnumField(Color)best_before=fields.DateField()sweet=fields.BooleanField()# NOTE: Replace with module name of your modelstortoise_converter=TortoiseConverter('cattrs_extras.tortoise.model')apple_model=tortoise_converter.structure(raw_apple,AppleModel)assertapple_model==AppleModel(weight=Decimal('200.5'),color=Color.RED,best_before=datetime(2020,4,2,12,0),sweet=True)raw_apple=tortoise_converter.unstructure(apple_model)assertraw_apple=={'id':None,'weight':'200.5','color':'RED','best_before':1585774800.0,'sweet':True}LimitationsPEP 563 – Postponed Evaluation of Annotationsis not supported at the moment. Attempt to import__future__.annotationsin module containing models will lead to exception. However you can still use strings as typehints.Backward relations in Tortoise models are ignored during structuring even if fetched. Not sure if we should fix it.
Package: catty
catty -- Concatenative programming integrated in PythonConcatenative programmingis a method and coding style that emphasizes functional composition through
implicit parameter passing and postfix notation. It is often understood asstack programming, mimicking the constraints of stack machines. While it
carries some hipster cred, it is popular in development circles involving
dedicated hardware. Its most popular incarnation is theFORTHlanguage; theFactorlanguage and platform provides a more modern
programming system over its principles.This project is an attempt at integrating a concatenative style and approach
to the Python language and software ecosystem. Its present incarnation is
somewhat clumsy as it parasites the Python syntax: a catty program is valid
Python code. The catty semantics also attempt to leverage the Python built-ins
and library as much as possible. Here is a taste:fromoperatorimportadd,mulfromcattyimportreducefromcatty.wordsimportdupresult=reduce([5,6,dup,mul,add])print(result)# Yields [41]So this early take yields the answer to life, the universe and everything,
but it's off by one. Should be fixed in next version.The interpretation is performed in a Python code loop, so speed cannot be
expected. However, the interpreter in its current form optimizes tail calls,
enabling arbitrary recursive applications:fromoperatorimportmulfromcattyimportreducefromcatty.wordsimportdup,tuck,fork,apply,Wordfactorial_=Word(# prod, n -- prod, n-1dup,0,eq,[],[dup,tuck,mul,swap,1,sub,apply.factorial_],fork)factorial=Word(# n -- n!1,swap,factorial_)print(reduce([5,factorial]))# Yields [120]This project is meant for incremental exploration of interactions between
concatenative and applicative programming styles. It will not shy away from
changing completely as it progresses. Current plans involve digging further
into tapping into namespace control through function definitions, replacing
the interpretation loop with Python bytecode generation, and further
strengthening integration so that concatenative and regular Python code can
live side by side.
Package: catwallpaper
What it does?Web Scraping Using Python to Download and Apply Random Cat Images as Wallpaper According to Your Operating SystemSupported platformsPresently, it provides support the following platforms mentioned below:WindowsMacLinux with desktop environment: Gnome, Xfce, Mate, Kde plasmaInstallationIt's available on pypi ashttps://pypi.org/project/catwallpaper/pip install catwallpaper
Package: cat-win
cat_winSimple Command-line Tool made in PythonExplore the code »Report Bug·Request FeatureTable of ContentsAbout The ProjectMade WithGetting StartedPrerequisitesInstallationUsageExamplesChangelogLicenseContactAbout The ProjectThis project copies the fundamental framework of the cat command-line tool from Linux and translates its features to an OS Independent program using Python.Over time the project evolved in subject areas of other tools like 'echo', 'grep', 'ls', 'base64'.Additionally it includes the feature to strip and reverse the content of any given file, make use of the standard-input, which enables cat piping into each other, generating the checksum of any file, converting decimal, hexadecimal and binary numbers within any text, and muchmore...It is of course possible to use cat_win on Linux or MacOS, aswell as Windows!Made With(back to top)Getting StartedPrerequisitesPython PackageUsing cat_win as a Python-Package demands a Python-Interpreter (>= 3.7).Binary ExecutableUsing cat_win as a binary executable demands no prerequisites, hereby the stand-alone executables are sufficient.InstallationPython PackageSimply install the python package (viaPyPI-cat_win):python -m pip install --upgrade cat_win[clip]cat_win uses thepyperclipmodule by default. Should any problems occur, you can also use
thepyperclip3orpyclipmodule.
In this case simply run:python -m pip install --upgrade cat_winand manually install the desired module yourself.On older Windows systems colored output may not be displayed correctly.
In this case you can try to fix the problem by installing the cat_win-package with the optional color-fix[cfix]dependency.
This fix will use thecoloramamodule
which can also be installed after the fact to patch the problem.Binary ExecutableOR alternativelyyou can use the (standalone) binary executable version:Direct Download:Windows -catw.exeWindows -cats.exe(shell)Linux -catwLinux -cats(shell)MacOS -catwMacOS -cats(shell)(compiled using PyInstaller)It is recommended to add the file path(s) to your system-environmentPATH-variables.⚠️You should never trust any executable file!Feel free to compile the package yourself (e.g. usingPyInstaller).You can verify the creation of the executable files yourself by reading thesource code, checking theoriginof the file and validating the correspondingworkflowused.(back to top)Usage> catw [FILE]... [OPTION]...> catw --helpConcatenate FILE(s) to standard output....> cats [OPTION]...> cats --helpInteractively manipulate standard input....👉 A detailedDocumentation🖺of allParametershas moved to another File.
Read about specificArguments & Optionshere.Examples📂 Images 📂$echo"Hello World :)"|catw-[6:]|catw-[::-1]-ln>1)[8]):dlroW$cats--eval--dec-nl>>>>0xF*51)[42]75[Bin:0b1001011,Oct:0o113,Hex:0x4b]>>>>...(back to top)ChangelogTake a look at theChangelogfile.LicenseThis project is licensed under the MIT License - see theLICENSEfile for detailsContactSilenZcience
Package: catwoman
catwoman: A transit modelling Python package for asymmetric light curvescatwomanis a Python package that models asymmetric transit lightcurves where planets are modelled as two semi-circles with different radii in any orientation, for any radially symmetric stellar limb darkening law.catwomanuses the integration algorithm developed for thebatmanpackage (Kreidberg 2015), from whichcatwomanbuilds upon.For a detailed introduction and more information please visithttps://catwoman.readthedocs.io/.catwomanwas peer reviewed by JOSS (Journal of Open Source Software) and Jones & Espinoza 2020 can be viewed herecatwomanhas been demonstrated and used inEspinoza & Jones 2021.InstallationYou can installcatwomanwith pip (recommended):$ pip install catwoman
Package: cat-zdm-sdk
Python SDK ofCAT <https://github.com/dianping/cat>.InstallationInstall via pip:$pipinstallcat-sdkCode Demoimportcatimporttimecat.init("appkey")withcat.Transaction("foo","bar")ast:try:t.add_data("hello")t.add_data("foo","bar")cat.log_event("hook","before")# do somethingexceptExceptionase:cat.log_exception(e)finally:cat.metric("api-count").count()cat.metric("api-duration").duration(100)cat.log_event("hook","after")time.sleep(1)DocumentationPlease checkGithubfor more information.Changeloghttps://github.com/dianping/cat/blob/master/lib/python/CHANGELOG.md
Package: catzzz
catzzzA package for getting more cats into your code.;,_            ,
                 _uP~"b          d"u,
                dP'   "b       ,d"  "o
               d"    , `b     d"'    "b
              l] [    " `l,  d"       lb
              Ol ?     "  "b`"=uoqo,_  "l
            ,dBb "b        "b,    `"~~TObup,_
          ,d" (db.`"         ""     "tbc,_ `~"Yuu,_
        .d" l`T'  '=                      ~     `""Yu,
      ,dO` gP,                           `u,   b,_  "b7
     d?' ,d" l,                           `"b,_ `~b  "1
   ,8i' dl   `l                 ,ggQOV",dbgq,._"  `l  lb
  .df' (O,    "             ,ggQY"~  , @@@@@d"bd~  `b "1
 .df'   `"           -=@QgpOY""     (b  @@@@P db    `Lp"b,
.d(                  _               "ko "=d_,Q`  ,_  "  "b,
Ql         .         `"qo,._          "tQo,_`""bo ;tb,    `"b,
qQ         |L           ~"QQQgggc,_.,dObc,opooO  `"~~";.   __,7,
qp         t\io,_           `~"TOOggQV""""        _,dg,_ =PIQHib.
`qp        `Q["tQQQo,_                          ,pl{QOP"'   7AFR`
  `         `tb  '""tQQQg,_             p" "b   `       .;-.`Vl'
             "Yb      `"tQOOo,__    _,edb    ` .__   /`/'|  |b;=;.__
                           `"tQQQOOOOP""`"\QV;qQObob"`-._`\_~~-._
                                """"    ._        /   | |oP"\_   ~\ ~\_~\
                                        `~"\ic,qggddOOP"|  |  ~\   `\~-._
                                          ,qP`"""|"   | `\ `;   `\   `\
                               _        _,p"     |    |   `\`;    |    |
       unknown                 "boo,._dP"       `\_  `\    `\|   `\   ;
                                 `"7tY~'            `\  `\    `|_   |
                                                      `~\  |Installation$ pip install catzzzUsage>>> import catzzz
Package: cauldron
Cauldron is an asyncio based library that removes boilerplate code when using databases.
Currently it supports using postgresql and redis.RequirementsPython >= 3.4.3asyncioInstallationTo install via pip:$pipinstallcauldronTo install from source:$gitclonehttps://github.com/nerandell/cauldron$cdcauldron$pythonsetup.pyinstallUsageCauldron currently supports postgres and redis. It usesaiopgandaioredisinternally but removes a lot of
boilerplate code that is usually written.Sample code using aiopg:importasynciofromaiopg.poolimportcreate_pooldsn='dbname=jetty user=nick password=1234 host=localhost port=5432'classUsePostgres():@classmethoddeftest_select(cls):pool=yield fromcreate_pool(dsn)with(yield frompool)asconn:cur=yield fromconn.cursor()yield fromcur.execute('SELECT 1')ret=yield fromcur.fetchone()assertret==(1,),retUsing Cauldron:fromcauldronimportPostgresStoreclassUseCauldron(PostgresStore):@classmethoddeftest_select(cls):rows=yield fromcls.raw_query('select 1')print(rows)Other Examplescauldronalso supports using different cursors in a way that you have to write minimal code.Using default cursorfromcauldronimportPostgresStoreclassUseCauldron(PostgresStore):@classmethod@cursordeftest_select(cls,cur):rows=yield fromcls.raw_sql('select * from users')print(rows)UsingnamedtuplecursorfromcauldronimportPostgresStoreclassUseCauldron(PostgresStore):@classmethod@nt_cursordeftest_select(cls,cur):rows=yield fromcls.raw_sql('select * from users')print(rows)Using dict cursor:fromcauldronimportPostgresStoreclassUseCauldron(PostgresStore):@classmethod@dict_cursordeftest_select(cls,cur):rows=yield fromcls.raw_sql('select * from users')print(rows)cauldronalso provides functionalities for common DB operations to make your code more readableInserting into db:fromcauldronimportPostgresStoreclassUseCauldron(PostgresStore):@classmethoddefstore_user(cls,username,password):insert_dict={'username':username,'password':password}yield fromcls.insert('user_table',insert_dict)Licensecauldronis offered under the MIT license.Source codeThe latest developer version is available in a github repository:https://github.com/nerandell/cauldron
Package: cauldron-hedgenull
Cauldron: Simple singletonsCauldron is a small, simple package that provides singleton functionality. Here's an example of how Cauldron can be used:>>>classMySingleton(other_base_classes,SingletonMixin):...def__init__(self,*args,**kwargs):...# do stuff here...pass...>>>singleton=MySingleton()>>>other_singleton=MySingleton()>>>id(singleton)==id(other_singleton)True
Package: caulk
ASmartFileOpen Source project.Read moreabout how SmartFile
uses and contributes to Open Source software.IntroductionThis package consists of a library and command line tool. The library allows
you to dump the Python objects in memory to a dump file.The command line tool is used to examine the dump file contents.Creating a dump file.To add memory dump capability to one of your Python applications, import the caulk
library and register a signal handler.import caulk

caulk.handler()A number of kwargs can control the operation of the signal handler.signum - The signal to react to, signal.SIGUSR1 by default.path - The path to which to write the dump file /var/tmp by default.name - The name of the dump file, ‘caulk’ by default..A dump file’s name will be: ‘{0}-{1}-{2}.dump’.format(name, pid, time).To generate a dump file, use kill:# kill -usr1 <pid>Where <pid> is the pid of your running application.You can also use the low-level API to generate a dump file directly
instead of relying on a signal handler.import caulk

caulk.dump('/var/tmp/my.dump')Examining a dump file.To examine the dump file, use the caulk command.# caulk --classes /var/tmp/caulk-1025-1346255743.435316.dump
count total  average min/max   class
----------------------------------------------------------------------
4     256    64      64/64     unittest.suite.TestSuite
1     64     64      64/64     unittest.runner._WritelnDecorator
1     64     64      64/64     site._Helper
...For more information on using the caulk command, see it’s help.# caulk --help
Package: caurus
CaurusCaurusis an open implementation of a verification scheme based on 2D barcodes.Getting StartedInstall and setup Caurus:$pipinstallcaurus
$caurusserverinitEach device needs to be activated first. In our case, we assign the (arbitrary) ID 1 and set a SVG viewer (e.g. a browser) to automatically display the barcodes:$ caurus server activate --viewer firefox 1To complete the activation, add the displayed keys tocaurus.cfg.Afterwards, your are ready to verify arbitrary messages. There is support for lines, key-value pairs and some basic styling:$ caurus server transaction 1 "Hello World!" "so:red:R" "many:blue:B" "colors:green:G"
Barcode: ...
Code: 231185Documentation→docs/DisclaimerThis project is not affiliated, associated, authorized, endorsed by, or in any way officially connected with Cronto Ltd, OneSpan Inc, or any of their subsidiaries or affiliates.
Package: causadb
CausaDB Command Line Interface (CLI) and Python ClientThis is the CLI and Python client for CausaDB, an easy-to-use platform for building and querying causal AI models in the cloud.DocumentationThe documentation for the CLI and Python client is available athttps://docs.causadb.com.InstallationTo install the CLI and Python client, runpipinstallcausadbYou can configure your account by runningcausadbaccountsetupYou'll be asked for an API key, which you can obtain from the CausaDB team. If you haven't been in touch with the team yet, you can reach out atmailto:causadb@causa.tech.
Package: causal-attribution
This package has two interfaces:score_vocab(): Given text (T), vocab (V), outcome(s) Y, and
confound(s) (C), this method will score each element of the
vocab according to how well it explains each Y, controlling
for all of the C’s.evaluate_vocab(): Measure’s the strength of a vocab’s causal
effects on Y (controlling for C).(c) Reid Pryzant 2019https://cs.stanford.edu/~rpryzant/May be used and distributed under the MIT license.