Saravanan666/pypi-org huggingface dataset:
Package: cool-ip-api
cool-ip-apiA package to get information from multiple IP APIs about the clients IP or another requested IP.InstallationRequires python  3.10 and above.pipinstallcool-ip-apiUsage# Example with IPApiCom APIfromcool_ip_api.provider.ip_api_comimportIPAPIComip_api_com=IPAPICom()ip_api_com.resolve()# Returns a pydantic model with the data from the APICli commandcool-ip-api
cool-ip-api1.1.1.1Supported APIsProviderFree plan available?Rate limitCheckIP Queryabstractapi.com✅20.000/monthapi-key✅ip-api.com✅45/minuteip✅ipwhois.io✅10.000/monthip✅ipapi.co✅1.000/dayip✅ipapi.com✅1.000/monthapi-key✅ipify.org✅NoneNone❌ipinfo.io✅50.000/monthapi-key✅myip.wtf✅ (Donate)1/minuteip❌TODOAdd more providersgeo.ipify.orgAdd bulk query support for providers that support itAdd premium plan support for providers that support itAdd more testsAsync testsRate limit testsAdd more documentation
Package: coolisf
Integrated Semantic FrameworkA Python 3 implementation of theIntegrated Semantic Frameworkthat provides computational deep semantic analysis by combining structural semantics from construction grammars and lexical semantics from ontologies in a single representation.coolisfis only a back-end semantic parsing module that runs on command-line interaface or in Python programs.
If you want a friendly graphical user interface, please usevisualkopasu.A quick glanceTo parse a sentence, use coolisftextcommandpython-mcoolisftext"I drink green tea."-fdmrs

:`Idrinkgreentea.`(len=5)------------------------------------------------------------
dmrs{10000[pron<0:1>xind=+num=sgpers=1pt=std];10001[pronoun_q<0:1>xind=+num=sgpers=1pt=std];10002[_drink_v_1_rel<2:7>emood=indicativeperf=-prog=-sf=proptense=pres];10003[udef_q<8:18>xnum=sgpers=3];10004[_green+tea_n_1_rel<8:18>xnum=sgpers=3];0:/H->10002;10001:RSTR/H->10000;10002:ARG1/NEQ->10000;10002:ARG2/NEQ->10004;10003:RSTR/H->10004;}# 10002 -> 01170052-v[drink/lelesk]# 10004 -> 07935152-n[green tea/lelesk]...For batch processing, create a text file with each sentence on a separate line.
For example here is the content of the filedemo.txtI drink green tea.
Sherlock Holmes has three guard dogs.
A soul is not a living thing.
Do you have any green tea chest?After that, run the followingparsecommand to analyse the text and write the output todemo_out.xmlpython-mcoolisfparsedemo.txt-odemo_out.xmlHere is an example of using coolisf in a Python codefromcoolisfimportGrammarHubghub=GrammarHub()# parse an English textsent=ghub.ERG_ISF.parse("I love drip coffee.")# print semantic structures for all potential readingsforreadinginsent:print(reading.dmrs())Outputdmrs{10000[pron<0:1>xind=+num=sgpers=1pt=std];10001[pronoun_q<0:1>xind=+num=sgpers=1pt=std];10002[_love_v_1_rel<2:6>emood=indicativeperf=-prog=-sf=proptense=pres];10003[udef_q<7:19>xnum=sgpers=3];10004[_drip+coffee_n_1_rel<7:19>xnum=sgpers=3];0:/H->10002;10001:RSTR/H->10000;10002:ARG1/NEQ->10000;10002:ARG2/NEQ->10004;10003:RSTR/H->10004;}...Fore more information, please refer to the documentation for coolisf athttps://coolisf.readthedocs.ioInstallThecoolisfpackage itself is available onPyPIand it can be installed using pippipinstallcoolisfHowever, it can be tricky to acquire all the required components and data. Please find version specific prerequisites and installation instructions on coolisf'sofficial Github release page.If you encounter any problems or difficulties, please submit a ticket for support at:https://github.com/letuananh/intsem.fx/issues
Package: coolkit-client-phoenix
# ewelink-sonoff-coolkit-clientClient for Sonoff devices using eWeLink accessInspired by https://github.com/peterbuga/HASS-sonoff-ewelink## Usage example```#!/usr/bin/env pythonimport asynciofrom coolkit_client import CoolkitSession, CoolkitDevicesRepositoryfrom coolkit_client.device_control import CoolkitDeviceControlfrom coolkit_client.discover import CoolkitDevicesDiscoveryasync def start():await CoolkitSession.login(username='my@email.com',password='IDoNotTellYou!',region='eu')await CoolkitDevicesRepository.get_device('1000012345').switches[0].state(True)await asyncio.sleep(1)await CoolkitDevicesRepository.get_device('1000012345').switches[0].state(False)await CoolkitDevicesDiscovery.discover()CoolkitDeviceControl.start_daemon()while True:await asyncio.sleep(3600)if __name__ == "__main__":loop = asyncio.get_event_loop()loop.run_until_complete(start())```
Package: coolledx
CoolLEDX DriverThis package implements a Python driver for the CoolLEDX LED strips (i.e., those strips
that are controlled by the CoolLED1248 app).  The strips receive commands via Bluetooth,
and can generally be programmed to display text (which is actually just a rendered image
of the text), images, or animations.  You can get these strips pretty cheaply on AliExpress
-- just be sure that you see a picture of the CoolLED1248 app on the product page, as this
driver won't work with any other sort of strip.  That said, they're pretty ubiquitous, at
least at the time of this writing (December 2023).UsageYou need to have a functioning Bluetooth device.  This package usesBleakfor all its Bluetooth interactions, so you should be able to use any system supported
by Bleak . . . but it hasn't been tested on anything other than Windows 11 (and soon
Ubuntu on a Pi).RoadmapWrite some bare-bones documentation, at leastEnsure this is tested out on a Raspberry Pi (my end target device)Add a simple REST listener app to allow driving this remotelyCredits and SourcesMain KudosThis project could not possibly exist without the work done byCrimsonClydein reverse engineering the CoolLEDX protocol atLED FaceShields.  Much
of the code in this project is directly derived from that code, and almost all of the
insights were from that work.  That repository has a bunch of useful information about
the underlying protocol.The Source?I believe that these LEDs are made byJuntong Technology.  I think that
the app itself is made by some 3rd party.  I sent an email to the contact at Juntong, but
never got a reply, so not sure.  If anyone has a contact, I'd love to get connected, as I
really like their strips!For source code related to the app, which was helpful in some questions I had about
the protocol (but, honestly, not too much there, and a headache to read), you could try:iOS App (Crosby) SourceSome other source that seems to poke the deviceSniffing the CoolLED1248 AppFor some of my protocol analysis, I found it useful to do the following:Turn on BLE logging on my Android phone (under developer options) to save a log capture.
Be sure to turn it on right before you start the capture, then turn it off immediately,
so that you're not collecting a ton of junk information.Run the CoolLED1248 app and send commands to the LED stripPull the log file from the phone to my PC using the ADB interfaceAnalyze it with Wireshark (just put a filter on the MAC address of the LED strip)This helped me get over some spots where I was a bit lost in the handshakes, or making
some bad assumptions about what was or was not working.
Package: cool-linear-solver
cool_linear_solver: An easy going (contrained) linear solver with sparse methods and minimal effortusage:fromcool_linear_solverimportVariable,System_of_linear_eqsT=Variable(name='T')print(T.coefs)print(T)eq1=T+T+T+T[1]+1*T[3.5]==1eq2=T+T+T[1]-4*T[3.5]==4eq3=T+T[1]/10+0*T[3.5]==-10.5print(eq1)print(eq2)print(eq3)sys=System_of_linear_eqs()sys.add_equation(eq1)sys.add_equation(eq2)sys.add_equation(eq3)#or use sys.add_equations([eq1,eq2,eq3]) or even `sys = quicksolver([eq1,eq2,eq3])`sys.solve()#solve using the pushed equationsprint('T=',sys[T])#evaluated T on the solutionprint('T[1]=',sys[T[1]])print('T[3.5]=',sys[T[3.5]])# print('T[2.5]=',sys[T[2.5]]) #this will throw an error for it was not present in the source equationsprint('eq1=',sys[eq1])#you can also evaluate expressionsAs can be seen you can use non-integer indexes and the notation is quite simple.Heat Equation Solving exampleIt uses a sparse solver so you can used it as a PDE solver such as solving the heat equationimportnumpyasnpN=200#creates and 200**2 by 200**2 sparse matrixNy=Nx=Ndx,dy=1/(Nx-1),1/(Ny-1)yar=np.linspace(0,1,num=Ny)xar=np.linspace(0,1,num=Nx)eqs=System_of_linear_eqs()T=Variable(name='T')foryiinrange(Ny):forxiinrange(Nx):x,y=xar[xi],yar[yi]ifx==0:if0.25<y<0.75:eqs.add_equation(T[x,y]==1)else:eqs.add_equation(T[x,y]==0)elify==0orx==1ory==1:eqs.add_equation(T[x,y]==0)else:#domain:eqs.add_equation(T[x,y]==0.25*(T[xar[xi+1],y]+T[xar[xi-1],y]+T[x,yar[yi+1]]+T[x,yar[yi-1]]))print(eqs.get_sparse_matrix().__repr__())# a sparse matrix is automaticly createdeqs.solve()Tar=[]foryiinrange(Ny):Trow=[]forxiinrange(Nx):x,y=xar[xi],yar[yi]Trow.append(eqs[T[x,y]])Tar.append(Trow)frommatplotlibimportpyplotaspltplt.contourf(xar,yar,Tar)plt.colorbar()plt.show()It can be quite slow in constructing the equations but that is not the goal of this module.
Package: coolmaker
Python sprites module introducePython sprites  is a module for make game and animation easily.anybody can make game and animation funny.
It's developed with Turtle module,In order to facilitate the beginners to make games, some functions are added,
such as Clock class can fix FPS, stamp can move, image can rotate,can detect keyboard keys and mouse keys a loop statement,
and add rectangle collision method. There are also functions such as bounce_on_edge and say functions.Main application scenarios:1、Introduction to children's computer games and animation development.
2、learn the ABC of Python game development.
3、Python game crash.
4、Getting started with Python for training institutions.
5、Python experience courses and public welfare courses of training institutions.more example,please conatct coolmaker,,website:http://www.coolguymaker.comsprites module Developer: coolmaker，email:wangyf@coolguymaker.com,Hangzhou, Zhejiang, China.
Package: cool-mapMapboxRoute
#COOLMAP ROUTE PATH ESTIMATIONInstallpip install cool-mapMapboxRouteInstructionsfrom cool_mapMapboxRoute.route_mapbox import CoolmapRoutePathobj = CoolmapRoutePath(<from_lat_log>,<to_lat_log>,<mapbox_api_key>)

#EXAMPLE:
    obj = CoolmapRoutePath("34.01076,-117.44858","33.94559,-118.18381",<mapbox_api_key>)#to get the path of route
obj.get_mapbox_response()#return estimated time of route
obj.estimated_time_in_minute()#return estimated distance of route
obj.estimated_distance_in_mile
Package: cool-maps
cool_mapsWrapper functions around the cartopy for plotting data on maps.
These functions are written to easily generate maps using some pre-defined settings that our lab, Rutgers Center for Ocean Observing Leadership, prefers to use.Free software: MIT licenseFeaturesTODOInstallationconda create -n cool_maps python=3.9
conda activate cool_maps
conda install –file requirements.txtStable releaseTo install cool_maps, run this command in your terminal:$pipinstallcool_mapsThis is the preferred method to install cool_maps, as it will always install the most recent stable release.If you don’t havepipinstalled, thisPython installation guidecan guide
you through the process.We also recommend using miniconda to manage your Python environments. Download and follow theMiniconda installation guidefor the appropriate
Miniconda installer for your operating system.Make sure to add the channel,conda-forge, to your .condarc. You can
find out more about conda-forge from their website:You can do this with the following command:conda config --add channels conda-forgeFrom sourcesThe sources for cool_maps can be downloaded from theGithub repo.You can either clone the public repository:$gitclonegit://github.com/rucool/cool_mapsOr download thetarball:$curl-OJLhttps://github.com/rucool/cool_maps/tarball/masterOnce you have a copy of the source, you can should create a new conda/virtual environment following the Installation instructions above.Running testsAfter setting up your environment, you can run all of the tests, provided you install ‘pytest’:$pytestCreditsThis package was created withCookiecutterand theconda/cookiecutter-conda-pythonproject template.History0.0.2 (2022-07-19)Modified requirements.txt to use a lower version of cartopy that is faster.0.0.1 (2022-05-20)Initial commit to GitHub
Package: coolmath1
coolmathA simple Python library for basic mathematical operations.InstallationYou can install this library using pip:pipinstallcoolmath1Usagefromcoolmath1importadd,subtract,multiply,divideresult_add=add(5,3)result_subtract=subtract(10,4)result_multiply=multiply(6,7)result_divide=divide(8,2)print(f"Addition: {result_add}")print(f"Subtraction: {result_subtract}")print(f"Multiplication: {result_multiply}")print(f"Division: {result_divide}")
Package: coolmit
Don’t just commit; coolmit. Make your commits cooler with coolmit today!
[![Build Status](https://travis-ci.org/awentzonline/coolmit.png)](https://travis-ci.org/awentzonline/coolmit)
[![Coverage Status](https://coveralls.io/repos/awentzonline/coolmit/badge.png)](https://coveralls.io/r/awentzonline/coolmit)Eliminate boring commit hashes! Withcoolmityou choose
the beginning of the commit hash, giving your commits thatcoolmitedge. Impress your boss and aggressively flex
your toned, bronze code muscle in the faces of your peers.This was inspired by one of the problems in Stripe’s CTF3.[Here’s a nice list of words you can make with hexadecimal characters.](http://nedbatchelder.com/text/hexwords.html)Installationpip install coolmitorpython setup.py installUsageTo update the hash of the current HEAD:git coolmit DESIRED_PREFIXE.g.:git coolmit beefLicenseMIT
Package: coolname
Do you want random human-readable strings?>>>fromcoolnameimportgenerate_slug>>>generate_slug()'big-maize-lori-of-renovation'>>>generate_slug()'tunneling-amaranth-rhino-of-holiness'>>>generate_slug()'soft-cuddly-shrew-of-expertise'FeaturesGenerate slugs, ready to use, Django-compatible.>>>fromcoolnameimportgenerate_slug>>>generate_slug()'qualified-agama-of-absolute-kindness'Generate names as sequences and do whatever you want with them.>>>fromcoolnameimportgenerate>>>generate()['beneficial','bronze','bee','of','glee']>>>' '.join(generate())'limber transparent toad of luck'>>>''.join(x.capitalize()forxingenerate())'CalmRefreshingTerrierOfAttraction'Generate names of specific length: 2, 3 or 4 words.>>>generate_slug(2)'mottled-crab'>>>generate_slug(3)'fantastic-acoustic-whale'>>>generate_slug(4)'military-diamond-tuatara-of-endeavor'Note: without argument, it returns a random length, but probability of 4‑word name is much higher.Prepositions and articles (of, from, the) are not counted as words.Use in command line:$coolnameprophetic-tireless-bullfrog-of-novelty$coolname3-n2-s'_'wildebeest_of_original_champagneara_of_imminent_luckOver 1010random names.WordsCombinationsExample41010talented-enigmatic-bee-of-hurricane3108ambitious-turaco-of-joviality2105prudent-armadillo>>>fromcoolnameimportget_combinations_count>>>get_combinations_count(4)62620779367Hand-picked vocabulary.sexyanddemonicare about the most “offensive” words here -
but there is only a pinch of them, for spice. Most words are either neutral, such asred, or positive,
such asbrave. And subject is always some animal, bird, fish, or insect - you can’t be more neutral than
Mother Nature.Easy customization. Create your own rules!>>>fromcoolnameimportRandomGenerator>>>generator=RandomGenerator({...'all':{...'type':'cartesian',...'lists':['first_name','last_name']...},...'first_name':{...'type':'words',...'words':['james','john']...},...'last_name':{...'type':'words',...'words':['smith','brown']...}...})>>>generator.generate_slug()'james-brown'Installationpipinstallcoolnamecoolnameis written in pure Python and has no dependencies. It works on any modern Python version (3.6+), including PyPy.Release history2.2.0 (2023-01-09)More dogs, cats and cows!2.1.0 (2022-12-07)Support OpenSSL FIPS by usinghashlib.md5(...,usedforsecurity=False)2.0.0 (2022-10-24)Support for old Python versions (<3.5) is dropped, because it’s 2022Command line usage and pipx support.With additional owls and bitterns1.1.0 (2018-08-02)32-bit Python is supported.1.0.4 (2018-02-17)Breaking changes:RenamedRandomNameGeneratortoRandomGenerator.randomizewas removed, because it was just an alias torandom.seed.Phrase listsgive you even more freedom when creating custom generators.You can seed or even replace the underlyingrandom.Randominstance, seeRandomization.Change the default generator usingCOOLNAME_DATA_DIRandCOOLNAME_DATA_MODULE. This also saves memory!Total number of combinations = 60 billions.For earlier releases, seeHistory
Package: coolours
CooloursA Python Module To Make Text Styling EasyMade By Alex HawkingInstallationWith PipInstall with:pip install cooloursorpip3 install cooloursWith wgetWget must be installedcd ~/Library/Python/3.7/lib/python/site-packages && wget https://raw.githubusercontent.com/Handmade-Studios/coolours-module/master/coolours/coolours.py && cd ~Probably easier to copy and paste that ^UsageImportingImport coolours using:from coolours.colour import *You can import withimport coolours.colourBut that requires you to useprint(coolours.colour('style', 'textcolour', 'backgroundcolour')), so I think it is easier to use the first method.ColoursYou use coolours within theprintfunction as shown below:print(colour('style', 'text-colour', 'background-colour') + 'your text')Make sure you place the colours and styles within quotesAlignmentCenterTo center text use:print(center('yourtext'))RightTo align text to the right use:print(right('yourtext'))With ColourTo use alignment with colour:print(colour('style', 'textcolour', 'bgcolour') + center('yourtext'))DefaultTo make the colours back to default after the coloured text adddefaultto the end of the print function:print(colour('style', 'text-colour', 'background-colour') + 'your text' + default)UpdatingTo update use:pip install --upgrade cooloursOr:pip3 install --upgrade cooloursList of ColoursCoolours contains the following colours:Stylesnoneboldunderline (not supported in all temrinals)blink (not supported in all terminals)Text ColoursnoneblackredgreenyellowbluepurplecyanwhitebrightblackbrightredbrightgreenbrightyellowbrightbluebrightpurplebrightcyanbrightwhiteBackground ColoursnoneblackredgreenyellowbluepurplecyanwhitebrightblackbrightredbrightgreenbrightyellowbrightbluebrightpurplebrightcyanbrightwhiteAlignmentsRightCenterFutureMore colours and styles coming soon. Will add some sort of fancy text.
Package: coolpackets
coolpacketsA python framework for sending and receiving custom packetsThis is used for an extension to Ableton Live. I will add features as I need them for that project.Usage example:import socket
import time
from typing import Union, Optional, List

from coolpackets.packet import Packet, Connection, PacketManager


class MidiPacket(Packet):
    _packet_group = "mrs"
    _alias = "\x00"

    a = int
    b = Union[int, float]
    c_is_optional = Optional[int]

    def on_recv(self):
        print("RECEIVED MidiPacket!", self.a, self.b, self.c_is_optional)
        self.respond(UselessPacket(cool=["1", "2", "3"]))


class UselessPacket(Packet):
    _alias = "useless"
    # _dump = False

    cool = List[str]

    def on_recv(self):
        print("RECEIVED UselessPacket!")

    def encode(self) -> bytes:
        return b""

    @classmethod
    def decode(cls, data: bytes):
        return cls(cool=["nice", "cool"])


PacketManager.dump_packets("./packet_dumps/demo_packet_dump.py")


# setup
srv = socket.socket()
srv.bind(('', 9056))
srv.listen(1)

cli = socket.socket()
cli.connect(('localhost', 9056))
peer, addr = srv.accept()

conn1 = Connection(cli)
conn2 = Connection(peer, addr, {'mrs'})

# main logic
pck = MidiPacket(a=3, b=7.4)
conn1.send(pck, lambda p: print(f"RECEIVED RESPONSE: {p}"))

# time to process packets. Usually we wouldn't just close the sockets
time.sleep(.1)

# cleanup
conn1.close()
conn2.close()
srv.close()

print("Done")
Package: coolpy
coolpyThis is a project demonstrating how publich a muon beam cooling module to PyPI##InstallationRun the following to install:'''python pip install coolpy'''##Usage'''python
from coolpy import quadrupoleGenerate "Qudarupole matrix!"'''Developing Hello WorldTo install coolpy, aling with the tool you need to develop and run tests, run the following in you r virtualenv:'''bash
$ pip install -e .[dev]
'''
Package: cool-ssg-lmpham1
cool_ssg_generatorA simple SSG generator made with Python.
Current version is 0.1.0DependenciesPython 3.8.5(or higher)InstallationMake sure you have installed Python version 3.8.5 or above. No other dependencies is currently needed.To clone this project, use:git clone https://github.com/lmpham1/cool_ssg_generator.gitThen, you'll probably want to navigate to the project's root folder:cd cool_ssg_generatorBasic UsageNavigate to the project folder (if you haven't done so already):cd cool_ssg_generatorGenerate a website from a file or folder:python cool_ssg --input <INPUT_FILE_OR_FOLDER>Default output folder is./dist/, to specify a custom output folder:python cool_ssg --input <INPUT_FILE_OR_FOLDER> --output <OUTPUT_FOLDER>CSS can be used via the--stylesheetflag:python cool_ssg --input <INPUT_FILE_OR_FOLDER> --stylesheet <STYLESHEET_URL>For more usage, please refer to:python cool_ssg -hCool FeaturesWanna know what make thecool_ssg_generatorso cool? Aside from the totally-intentional doubled 'generator' in the name, it offers the following awesome features:Support multiple stylesheets! Simply use the-sor--stylesheetflags and separate each stylesheet link with space' ', i.e.:python cool_ssg -i index.txt -s sheet1.css sheet2.css sheet3.cssMarkdown (.md files) support forbold(**example**or__example__),italics(*example*or_example_), andlinks([Example](www.example.com))Language for the output HTML documents can be configured with-lor--langflag (default isen-CA):python cool_ssg -i test.txt -l en-UKNote: No validation for--lang/-loption is implemented yet. See issue#14for more informationYou can save your command-line options in a config file! No need to manually type all the options everytime, just use--config/-cflag with a json file:python cool_ssg -c config.jsonNote: Using--config/-coption will ignore/override other optionsLicenseMIT
Package: cooltables
CoolTablesSimple tool for making tables, no requirements. Check out example.pyUsageThe best way to get started is by using thecooltables.create_table()function.importcooltables# Some two dimensional listdata=[["First","Row","(header)"],["Second","Row","data"],["Third","Row","data"],]table=cooltables.create_table(data,theme=cooltables.THIN_THEME)print(table)This code produces the following output:┌────────┬─────┬──────────┐
│ First  │ Row │ (header) │
├────────┼─────┼──────────┤
│ Second │ Row │ data     │
│ Third  │ Row │ data     │
└────────┴─────┴──────────┘