{ "info": { "author": "Thomas Roehl", "author_email": "thomas.roehl@googlemail.com", "bugtrack_url": null, "classifiers": [ "Development Status :: 3 - Alpha", "Intended Audience :: Developers", "Intended Audience :: Science/Research", "License :: OSI Approved :: GNU General Public License v2 (GPLv2)", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Topic :: Scientific/Engineering", "Topic :: Software Development", "Topic :: Utilities" ], "description": "pylikwid\n========\n\nPython interface for the C API of LIKWID\n(https://github.com/RRZE-HPC/likwid)\n\n.. image:: https://travis-ci.org/RRZE-HPC/pylikwid.svg?branch=master\n :target: https://travis-ci.org/RRZE-HPC/pylikwid?branch=master\n\nInstallation\n============\n\nI added a setup.py script for the installation. It builds the C module\nand copies it to the proper destination.\n\n::\n\n $ git clone https://github.com/RRZE-HPC/pylikwid.git\n $ cd pylikwid\n # Build C interface\n $ python setup.py build_ext -I -L -R \n # Install module to the proper location\n $ python setup.py install (--prefix=)\n # Testing\n $ python -c \"import pylikwid\"\n $ ./testlib.py\n\nFunctions\n=========\n\nAfter ``import pylikwid`` you can call the following functions:\n\nMarker API\n----------\n\n- ``pylikwid.init()``: Initialize the Marker API of the LIKWID library.\n Must be called previous to all other functions.\n- ``pylikwid.threadinit()``: Add the current thread to the Marker API.\n Since Python is commonly single-threaded simply call it directly\n after ``pylikwid.init()``\n- ``rr = pylikwid.registerregion(regiontag)``: Register a region to the\n Marker API. This is an optional function to reduce the overhead of\n region registration at ``pylikwid.startregion``. If you don't call\n ``pylikwid.registerregion(regiontag)``, the registration is done at\n ``pylikwid.startregion(regiontag)``. On success, 0 is return. If you\n havn't called ``pylikwid.init()``, a negative number is returned.\n- ``err = pylikwid.startregion(regiontag)``: Start measurements under\n the name ``regiontag``. On success, 0 is return. If you havn't called\n ``pylikwid.init()``, a negative number is returned.\n- ``err = pylikwid.stopregion(regiontag)``: Stop measurements under the\n name ``regiontag`` again. On success, 0 is return. If you havn't\n called ``pylikwid.init()``, a negative number is returned.\n- ``num_events, events[], time, count = pylikwid.getregion(regiontag)``:\n Get the intermediate results of the region identified by\n ``regiontag``. On success, it returns the number of events in the\n current group, a list with all the aggregated event results, the\n measurement time for the region and the number of calls.\n- ``pylikwid.nextgroup()``: Switch to the next event set in a\n round-robin fashion. If you have set only one event set on the\n command line, this function performs no operation.\n- ``pylikwid.close()``: Close the connection to the LIKWID Marker API\n and write out measurement data to file. This file will be evaluated\n by ``likwid-perfctr``.\n- ``pylikwid.getprocessorid()``: Returns the ID of the currently\n executing CPU\n- ``pylikwid.pinprocess(cpuid)``: Pins the current process to the CPU\n given as ``cpuid``.\n- ``pylikwid.pinthread(cpuid)``: Pins the current thread to the CPU\n given as ``cpuid``.\n\nTopology\n--------\n\n- ``pylikwid.inittopology()``: Initialize the topology module (reads in\n system topology)\n- ``infodict = pylikwid.getcpuinfo()``: Return a dict with general\n information about the system (CPU model, CPU family, ...)\n\n - ``osname``: Name of the CPU retrieved from the CPUID leafs\n - ``name``: Name of the micro architecture\n - ``short_name``: Short name of the micro architecture\n - ``family``: ID of the CPU family\n - ``model``: Vendor-specific model number of the CPU\n - ``stepping``: Stepping (Revision) of the CPU\n - ``perf_version``: Version number of the hardware performance\n monitoring capabilities\n - ``perf_num_ctr``: Amount of general-purpose counter registers per\n hardware thread\n - ``perf_num_fixed_ctr``: Amount of fixed-purpose counter registers\n per hardware thread\n - ``perf_width_ctr``: Bit length of the counter registers\n - ``clock``: CPU clock (only unequal to 0 if timer module is\n initialized)\n - ``turbo``: Is turbo mode supported?\n - ``isIntel``: Is it an Intel CPU?\n - ``supportUncore``: Does the system have performance monitoring\n counters in the Uncore?\n - ``features``: String with performance relevant CPU features (AVX,\n SSE, ...)\n - ``featureFlags``: Bitmask for all available CPU features\n\n- ``topodict = pylikwid.getcputopology()``: Return a dict with the\n topology of the system. Here is a list of fields in the dict:\n\n - ``numSockets``: Number of CPU sockets\n - ``numHWThreads``: Number of hardware threads (physical +\n hyperthreading cores)\n - ``activeHWThreads``: Number of active/usable hardware threads\n - ``numCoresPerSocket``: Amount of hardware threads per CPU socket\n - ``numThreadsPerCore``: Amount of hardware threads assembled in\n every physical CPU core\n - ``numCacheLevels``: Amount of levels in cacheing hierarchy\n - ``cacheLevels``: Dict with information about the cache levels,\n keys are the levels (1, 2, 3,...)\n\n - ``level``: Level of the cache in the hierarchy\n - ``lineSize``: Size of a cache line\n - ``sets``: Amount of sets\n - ``inclusive``: Is the cache inclusive or exclusive?\\`\n - ``threads``: Amount of threads attached to the cache\n - ``associativity``: Associativity of the cache\n - ``type``: data (= data cache), unified = (data + instruction\n cache)\n - ``size``: Size of the cache in bytes\n\n - ``threadPool``: Dict with information about the hardware threads.\n Keys are the os-generated ID of the hardware thread\n\n - ``coreId``: ID of the corresponding physical core\n - ``apicId``: ID set by the operating system\n - ``threadId``: ID of the hardware thread in the physical core\n - ``packageId``: ID of the CPU socket hosting the hardware thread\n\n- ``pylikwid.printsupportedcpus()``: Prints all supported micro\n architecture names to stdout\n- ``pylikwid.finalizetopology()``: Delete all information in the\n topology module\n\nNUMA\n----\n\n- ``numadict = pylikwid.initnuma()``: Initialize the NUMA module and\n return the gathered values\n\n - ``numberOfNodes``: Amount of NUMA nodes in the system\n - ``nodes``: Dict holding the information about the NUMA domains.\n Keys are the NUMA domain IDs\n\n - ``id``: ID of the NUMA domain (should be equal to dict key)\n - ``numberOfProcessors``: Number of hardware threads attached to\n the NUMA domain\n - ``processors``: List of all CPU IDs attached to the NUMA domain\n - ``freeMemory``: Amount of free memory in the NUMA domain (in\n Kbytes)\n - ``totalMemory``: Amount of total memory in the NUMA domain (in\n Kbytes)\n - ``numberOfDistances``: How many distances to self/other NUMA\n domains\n - ``distances``: List with distances, NUMA domain IDs are the\n destination indexes in the list\n\n- ``pylikwid.finalizenuma()``: Delete all information in the NUMA\n module\n\nAffinity\n--------\n\n- ``affdict = pylikwid.initaffinity()``: Initialize the affinity domain\n module and return the gathered values\n\n - ``numberOfAffinityDomains``: Amount of affinity domains\n - ``numberOfSocketDomains``: Amount of CPU socket related affinity\n domains\n - ``numberOfNumaDomains``: Amount of NUMA related affinity domains\n - ``numberOfCacheDomains``: Amount of last level cache related\n affinity domains\n - ``numberOfProcessorsPerSocket``: Amount of hardware threads per\n CPU socket\n - ``numberOfCoresPerCache``: Amount of physical CPU cores per last\n level cache\n - ``numberOfProcessorsPerCache``: Amount of hardware threads per\n last level cache\n - ``domains``: Dict holding the information about the affinity\n domains\n\n - ``tag``: Name of the affinity domain (N = node, SX = socket X,\n CY = cache Y, MZ = memory domain Z)\n - ``numberOfProcessors``: Amount of hardware threads in the\n domain\n - ``numberOfCores``: Amount of physical CPU cores in the domain\n - ``processorList``: List holding the CPU IDs in the domain\n\n- ``pylikwid.finalizeaffinity()``: Delete all information in the\n affinity domain module\n- ``pylikwid.cpustr_to_cpulist()``: Transform a valid cpu string in\n LIKWID syntax into a list of CPU IDs\n\nTimer\n-----\n\n- ``pylikwid.getcpuclock()``: Return the CPU clock\n- ``t_start = pylikwid.startclock()``: Start the clock and return the\n current timestamp\n- ``t_end = pylikwid.stopclock()``: Stop the clock and return the\n current timestamp\n- ``t = pylikwid.getclock(t_start, t_end)``: Return the time in seconds\n between ``t_start`` and ``t_end``\n- ``c = pylikwid.getclockcycles(t_start, t_end)``: Return the amount of\n CPU cycles between ``t_start`` and ``t_end``\n\nTemperature\n-----------\n\n- ``pylikwid.inittemp(cpu)``: Initialize the temperature module for CPU\n ``cpu``\n- ``pylikwid.readtemp(cpu)``: Read the current temperature of CPU\n ``cpu``\n\nEnergy\n------\n\n- ``pinfo = pylikwid.getpowerinfo()``: Initializes the energy module\n and returns gathered information. If it returns ``None``, there is no\n energy support\n\n - ``minFrequency``: Minimal possible frequency of a CPU core\n - ``baseFrequency``: Base frequency of a CPU core\n - ``hasRAPL``: Are energy reading supported?\n - ``timeUnit``: Time unit\n - ``powerUnit``: Power unit\n - ``domains``: Dict holding the information about the energy\n domains. Keys are PKG, PP0, PP1, DRAM\n\n - ``ID``: ID of the energy domain\n - ``energyUnit``: Unit to derive raw register counts to uJ\n - ``supportInfo``: Is the information register available?\n - ``tdp``: TDP of the domain (only if supportInfo == True)\n - ``minPower``: Minimal power consumption by the domain (only if\n supportInfo == True)\n - ``maxPower``: Maximal power consumption by the domain (only if\n supportInfo == True)\n - ``maxTimeWindow``: Maximal time window between updates of the\n energy registers\n - ``supportStatus``: Are energy readings from the domain are\n possible?\n - ``supportPerf``: Is power capping etc. available?\n - ``supportPolicy``: Can we set a power policy for the domain?\n\n- ``e_start = pylikwid.startpower(cpu, domainid)``: Return the start\n value for a cpu for the domain with ``domainid``. The ``domainid``\n can be found in ``pinfo[\"domains\"][domainname][\"ID\"]``\n- ``e_stop = pylikwid.stoppower(cpu, domainid)``: Return the stop value\n for a cpu for the domain with ``domainid``. The ``domainid`` can be\n found in ``pinfo[\"domains\"][domainname][\"ID\"]``\n- ``e = pylikwid.getpower(e_start, e_stop, domainid)``: Calculate the\n uJ from the values retrieved by ``startpower`` and ``stoppower``.\n\nConfiguration\n-------------\n\n- ``pylikwid.initconfiguration()``: Read in config file from different\n places. Default is ``/etc/likwid.cfg``\n- ``config = pylikwid.getconfiguration()``: Get the dict with the\n configuration options\n\n - ``configFileName``: Path to the config file\n - ``topologyCfgFileName``: If a topology file was created with\n ``likwid-genTopoCfg`` and found by ``initconfiguration()``\n - ``daemonPath``: Path to the access daemon executable\n - ``groupPath``: Path to the base directory with the performance\n group files\n - ``daemonMode``: Configured access mode (0=direct, 1=accessDaemon)\n - ``maxNumThreads``: Maximal amount of hardware threads that can be\n handled by LIKWID\n - ``maxNumNodes``: Maximal amount of CPU sockets that can be handled\n by LIKWID\n\n- ``pylikwid.destroyconfiguration()``: Destroy all information about\n the configuration\n\nAccess module\n-------------\n\n- ``pylikwid.hpmmode(mode)``: Set access mode. For x86 there are two\n modes:\n\n - ``mode = 0``: Access the MSR and PCI devices directly. May require\n root access\n - ``mode = 1``: Access the MSR and PCI devices through access daemon\n instances\n\n- ``pylikwid.hpminit()``: Initialize the access functions according to\n the access mode\n- ``pylikwid.hpmaddthread(cpu)``: Add CPU ``cpu`` to the access layer\n (opens devices files or connection to an access daemon)\n- ``pylikwid.hpmfinalize()``: Unregister all CPUs from the access layer\n and close files/connections\n\nPerformance Monitoring\n----------------------\n\n- ``pylikwid.init(cpus)``: Initialize the perfmon module for the CPUs\n given in list ``cpus``\n- ``pylikwid.getnumberofthreads()``: Return the number of threads\n initialized in the perfmon module\n- ``pylikwid.getnumberofgroups()``: Return the number of groups\n currently registered in the perfmon module\n- ``pylikwid.getgroups()``: Return a list of all available groups. Each\n list entry is a dict:\n\n - ``Name``: Name of the performance group\n - ``Short``: Short information about the performance group\n - ``Long``: Long description of the performance group\n\n- ``gid = pylikwid.addeventset(estr)``: Add a performance group or a\n custom event set to the perfmon module. The ``gid`` is required to\n specify the event set later\n- ``pylikwid.getnameofgroup(gid)``: Return the name of the group\n identified by ``gid``. If it is a custom event set, the name is set\n to ``Custom``\n- ``pylikwid.getshortinfoofgroup(gid)``: Return the short information\n about a performance group\n- ``pylikwid.getlonginfoofgroup(gid)``: Return the description of a\n performance group\n- ``pylikwid.getnumberofevents(gid)``: Return the amount of events in\n the group\n- ``pylikwid.getnumberofmetrics(gid)``: Return the amount of derived\n metrics in the group. Always 0 for custom event sets.\n- ``pylikwid.getnameofevent(gid, eidx)``: Return the name of the event\n identified by ``gid`` and the index in the list of events\n- ``pylikwid.getnameofcounter(gid, eidx)``: Return the name of the\n counter register identified by ``gid`` and the index in the list of\n events\n- ``pylikwid.getnameofmetric(gid, midx)``: Return the name of a derived\n metric identified by ``gid`` and the index in the list of metrics\n- ``pylikwid.setup(gid)``: Program the counter registers to measure all\n events in group ``gid``\n- ``pylikwid.start()``: Start the counter registers\n- ``pylikwid.stop()``: Stop the counter registers\n- ``pylikwid.read()``: Read the counter registers (stop->read->start)\n- ``pylikwid.switch(gid)``: Switch to group ``gid``\n (stop->setup(gid)->start)\n- ``pylikwid.getidofactivegroup()`` Return the ``gid`` of the currently\n configured group\n- ``pylikwid.getresult(gid, eidx, tidx)``: Return the raw counter\n register result of all measurements identified by group ``gid`` and\n the indices for event ``eidx`` and thread ``tidx``\n- ``pylikwid.getlastresult(gid, eidx, tidx)``: Return the raw counter\n register result of the last measurement cycle identified by group\n ``gid`` and the indices for event ``eidx`` and thread ``tidx``\n- ``pylikwid.getmetric(gid, midx, tidx)``: Return the derived metric\n result of all measurements identified by group ``gid`` and the\n indices for metric ``midx`` and thread ``tidx``\n- ``pylikwid.getlastmetric(gid, midx, tidx)``: Return the derived\n metric result of the last measurement cycle identified by group\n ``gid`` and the indices for metric ``midx`` and thread ``tidx``\n- ``pylikwid.gettimeofgroup(gid)``: Return the measurement time for\n group identified by ``gid``\n- ``pylikwid.finalize()``: Reset all used registers and delete internal\n measurement results\n\nMarker API result file reader\n-----------------------------\n\n- ``pylikwid.markerreadfile(filename)``: Reads in the result file of an\n application run instrumented by the LIKWID Marker API\n- ``pylikwid.markernumregions()``: Return the number of regions in an\n application run\n- ``pylikwid.markerregiontag(rid)``: Return the region tag for the\n region identified by ``rid``\n- ``pylikwid.markerregiongroup(rid)``: Return the group name for the\n region identified by ``rid``\n- ``pylikwid.markerregionevents(rid)``: Return the amount of events for\n the region identified by ``rid``\n- ``pylikwid.markerregionthreads(rid)``: Return the amount of threads\n that executed the region identified by ``rid``\n- ``pylikwid.markerregiontime(rid, tidx)``: Return the accumulated\n measurement time for the region identified by ``rid`` and the thread\n index ``tidx``\n- ``pylikwid.markerregioncount(rid, tidx)``: Return the call count for\n the region identified by ``rid`` and the thread index ``tidx``\n- ``pylikwid.markerregionresult(rid, eidx, tidx)``: Return the call\n count for the region identified by ``rid``, the event index ``eidx``\n and the thread index ``tidx``\n- ``pylikwid.markerregionmetric(rid, midx, tidx)``: Return the call\n count for the region identified by ``rid``, the metric index ``midx``\n and the thread index ``tidx``\n\nUsage\n=====\n\nMarker API\n----------\n\nCode\n~~~~\n\nHere is a small example Python script how to use the LIKWID Marker API\nin Python:\n\n::\n\n #!/usr/bin/env python\n\n import pylikwid\n\n pylikwid.init()\n pylikwid.threadinit()\n liste = []\n pylikwid.startregion(\"listappend\")\n for i in range(0,1000000):\n liste.append(i)\n pylikwid.stopregion(\"listappend\")\n nr_events, eventlist, time, count = pylikwid.getregion(\"listappend\")\n for i, e in enumerate(eventlist):\n print(i, e)\n pylikwid.close()\n\nThis code simply measures the hardware performance counters for\nappending 1000000 elements to a list. First the API is initialized with\n``likwid.init()`` and ``likwid.threadinit()``. Afterwards it creates an\nempty list, starts the measurements with\n``likwid.startregion(\"listappend\")`` and executes the appending loop.\nWhen the loop has finished, we stop the measurements again using\n``likwid.stopregion(\"listappend\")``. Just for the example, we get the\nvalues inside our script using ``likwid.getregion(\"listappend\")`` and\nprint out the results. Finally, we close the connection to the LIKWID\nMarker API.\n\nYou always have to use ``likwid-perfctr`` to program the hardware\nperformance counters and specify the CPUs that should be measured. Since\nPython is commonly single-threaded, the cpu set only contains one entry:\n``likwid-perfctr -C 0 -g -m `` This pins the\nPython interpreter to CPU 0 and measures ```` for all regions\nin the Python script. You can set multiple event sets by adding multiple\n``-g `` to the command line. Please see the LIKWID page for\nfurther information how to use ``likwid-perfctr``. Link:\nhttps://github.com/rrze-likwid/likwid\n\nExample\n~~~~~~~\n\nUsing the above Python script we can measure the L2 to L3 cache data\nvolume:\n\n::\n\n $ likwid-perfctr -C 0 -g L3 -m ./test.py\n --------------------------------------------------------------------------------\n CPU name: Intel(R) Core(TM) i7-4770 CPU @ 3.40GHz\n CPU type: Intel Core Haswell processor\n CPU clock: 3.39 GHz\n --------------------------------------------------------------------------------\n (0, 926208305.0)\n (1, 325539316.0)\n (2, 284626172.0)\n (3, 1219118.0)\n (4, 918368.0)\n Wrote LIKWID Marker API output to file /tmp/likwid_17275.txt\n --------------------------------------------------------------------------------\n ================================================================================\n Group 1 L3: Region listappend\n ================================================================================\n +-------------------+----------+\n | Region Info | Core 0 |\n +-------------------+----------+\n | RDTSC Runtime [s] | 0.091028 |\n | call count | 1 |\n +-------------------+----------+\n\n +-----------------------+---------+--------------+\n | Event | Counter | Core 0 |\n +-----------------------+---------+--------------+\n | INSTR_RETIRED_ANY | FIXC0 | 9.262083e+08 |\n | CPU_CLK_UNHALTED_CORE | FIXC1 | 3.255393e+08 |\n | CPU_CLK_UNHALTED_REF | FIXC2 | 2.846262e+08 |\n | L2_LINES_IN_ALL | PMC0 | 1.219118e+06 |\n | L2_TRANS_L2_WB | PMC1 | 9.183680e+05 |\n +-----------------------+---------+--------------+\n\n +-------------------------------+--------------+\n | Metric | Core 0 |\n +-------------------------------+--------------+\n | Runtime (RDTSC) [s] | 0.09102752 |\n | Runtime unhalted [s] | 9.596737e-02 |\n | Clock [MHz] | 3.879792e+03 |\n | CPI | 3.514753e-01 |\n | L3 load bandwidth [MBytes/s] | 8.571425e+02 |\n | L3 load data volume [GBytes] | 0.078023552 |\n | L3 evict bandwidth [MBytes/s] | 6.456899e+02 |\n | L3 evict data volume [GBytes] | 0.058775552 |\n | L3 bandwidth [MBytes/s] | 1.502832e+03 |\n | L3 data volume [GBytes] | 0.136799104 |\n +-------------------------------+--------------+\n\nAt first a header with the current system type and clock is printed.\nAfterwards the output of the Python script lists the results of the\nmeasurements we got internally with ``likwid.getregion``. The next\noutput is the region results evaluated by ``likwid-perfctr`` and prints\nat first a headline stating the measured eventset, here ``L3`` and the\nregion name ``listappend``. Afterwards 2 or 3 tables are printed. At\nfirst some basic information about the region like run time (or better\nmeasurement time) and the number of calls of the region. The next table\ncontains the raw values for each event in the eventset. These numbers\nare similar to the ones we got internally with ``likwid.getregion``. If\nyou have set an performance group (here ``L3``) instead of a custom\nevent set, the raw results are derived to commonly used metrics, here\nthe ``CPI`` (Cycles per instruction, lower is better) and different\nbandwidths and data volumes. You can see, that the load bandwidth for\nthe small loop is 857 MByte/s and the evict (write) bandwidth is 645\nMByte/s. In total we have a bandwidth of 1502 MByte/s.\n\nFull API\n--------\n\nCode\n~~~~\n\n::\n\n #!/usr/bin/env python\n\n import pylikwid\n\n liste = []\n cpus = [0,1]\n\n pylikwid.init(cpus)\n group = pylikwid.addeventset(\"INSTR_RETIRED_ANY:FIXC0\")\n pylikwid.setup(group)\n pylikwid.start()\n for i in range(0,1000000):\n liste.append(i)\n pylikwid.stop()\n for thread in range(0,len(cpus)):\n print(\"Result CPU %d : %f\" % (cpus[thread], pylikwid.getresult(group,0,thread)))\n pylikwid.finalize()\n\nExample\n~~~~~~~\n\n::\n\n $ ./test.py\n Result CPU 0 : 87335.000000\n Result CPU 1 : 5222188.000000\n\nFurther comments\n================\n\nPlease be aware that Python is a high-level language and your simple\ncode is translated to a lot of Assembly instructions. The ``CPI`` value\nis commonly low (=> good) for high-level languages because they have to\nperform type-checking and similar stuff that can be executed fast in\ncomparison to the CPU clock. If you would compare the results to a lower\nlevel language like C or Fortran, the ``CPI`` will be worse for them but\nthe performance will be higher as no type-checking and transformations\nneed to be done.", "description_content_type": "", "docs_url": null, "download_url": "", "downloads": { "last_day": -1, "last_month": -1, "last_week": -1 }, "home_page": "https://github.com/RRZE-HPC/pylikwid", "keywords": "hpc performance benchmark analysis", "license": "GPLv2", "maintainer": "", "maintainer_email": "", "name": "pylikwid", "package_url": "https://pypi.org/project/pylikwid/", "platform": "", "project_url": "https://pypi.org/project/pylikwid/", "project_urls": { "Homepage": "https://github.com/RRZE-HPC/pylikwid" }, "release_url": "https://pypi.org/project/pylikwid/0.3.1/", "requires_dist": null, "requires_python": "", "summary": "A Python module to access the function of the LIKWID library", "version": "0.3.1" }, "last_serial": 5182751, "releases": { "0.1": [], "0.1.3": [ { "comment_text": "", "digests": { "md5": "bc4c3726be71fdb5ff3870e85b615151", "sha256": "1820b9b9499419b6ea36fdc33a3d3b61ffa973f9eb91afb9f0390e407aa1f80a" }, "downloads": -1, "filename": "pylikwid-0.1.3.tar.gz", "has_sig": false, "md5_digest": "bc4c3726be71fdb5ff3870e85b615151", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 9921, "upload_time": "2017-04-19T14:45:27", "url": "https://files.pythonhosted.org/packages/96/d4/f02f80ecb31fb68cb5eb6bedba384b69cbdf626b548eeba9c2785947756b/pylikwid-0.1.3.tar.gz" } ], "0.2": [ { "comment_text": "", "digests": { "md5": "61d1b0c119110bda37a1b77dc53bec61", "sha256": "a360ec589467283f008b3d775d8f1272c41dc3028fe4f25e06e6edd3a4f46b02" }, "downloads": -1, "filename": "pylikwid-0.2.tar.gz", "has_sig": false, "md5_digest": "61d1b0c119110bda37a1b77dc53bec61", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 9627, "upload_time": "2017-04-19T14:58:38", "url": "https://files.pythonhosted.org/packages/99/9b/a60541be31908fff3eece082de5a51b04a2a5b6ccc8a7537413ed62da845/pylikwid-0.2.tar.gz" } ], "0.2.1": [ { "comment_text": "", "digests": { "md5": "4d66b52716ed6f2c2544a86e63f9dc74", "sha256": "51750cb3e42b82487a2c32a62ad1ff431717e758d9a2a63bd572d8bd0c6e3d5e" }, "downloads": -1, "filename": "pylikwid-0.2.1.tar.gz", "has_sig": false, "md5_digest": "4d66b52716ed6f2c2544a86e63f9dc74", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 15431, "upload_time": "2017-04-20T10:31:21", "url": "https://files.pythonhosted.org/packages/20/b6/7e709b1a3a343f579ea93d3eda092196da366c3fd807e01f5d7dc48c244a/pylikwid-0.2.1.tar.gz" } ], "0.2.2": [ { "comment_text": "", "digests": { "md5": "41141534d45b18727e267a25b07f80fa", "sha256": "7ee5125afe1d477d7c6f589bafc31587351a72dffaaca62809ca4a1c4ed1aa78" }, "downloads": -1, "filename": "pylikwid-0.2.2.tar.gz", "has_sig": false, "md5_digest": "41141534d45b18727e267a25b07f80fa", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 30733, "upload_time": "2017-12-21T11:30:57", "url": "https://files.pythonhosted.org/packages/d7/5f/711a228e4280b82d6321e193487252cc0df8cf07eeca9bca83b81def9243/pylikwid-0.2.2.tar.gz" } ], "0.2.3": [ { "comment_text": "", "digests": { "md5": "ea7f92d44d9e4c0e528e4a97f4b2b7c7", "sha256": "e4321a21dfa6cdf75f7fcbe6a8dbc1ba9b83afe06623693e2f0fd1282a8a935a" }, "downloads": -1, "filename": "pylikwid-0.2.3.tar.gz", "has_sig": false, "md5_digest": "ea7f92d44d9e4c0e528e4a97f4b2b7c7", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 30760, "upload_time": "2018-01-02T14:47:12", "url": "https://files.pythonhosted.org/packages/48/36/b355fe713a1de2434af8f552d6f4d23eac36772e1e56078a2ee46699befd/pylikwid-0.2.3.tar.gz" } ], "0.2.4": [ { "comment_text": "", "digests": { "md5": "339cad9dd1ef4b5dd6c986c53cfb357b", "sha256": "25548d049d8fb37b3dd7fee8aefe9282f04d424442a5b04d16711af85acbd8b4" }, "downloads": -1, "filename": "pylikwid-0.2.4.tar.gz", "has_sig": false, "md5_digest": "339cad9dd1ef4b5dd6c986c53cfb357b", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 30958, "upload_time": "2018-01-02T15:14:18", "url": "https://files.pythonhosted.org/packages/bd/73/a8baea30ebd31e4ba6ae5110a83dfdacdc4c5c527ff5e1abf8038499a753/pylikwid-0.2.4.tar.gz" } ], "0.2.5": [ { "comment_text": "", "digests": { "md5": "1757e1ffeb37e7c82c3dc9101ee95ab6", "sha256": "6ed18cd8d897764a318be4333a8649801ece755ed6be6e1c9be24793ef3100df" }, "downloads": -1, "filename": "pylikwid-0.2.5.tar.gz", "has_sig": false, "md5_digest": "1757e1ffeb37e7c82c3dc9101ee95ab6", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 31072, "upload_time": "2018-05-29T13:08:43", "url": "https://files.pythonhosted.org/packages/c2/ca/5e1df2fed6ecc90f5b748d275c77906b96107026eb437b4b5204f843f0e3/pylikwid-0.2.5.tar.gz" } ], "0.2.6": [ { "comment_text": "", "digests": { "md5": "83f0fd3bf8ce1ae94b50a7b6be99a5dd", "sha256": "7e2495a9cedfde2340ad7852a84010cc6a045748428bc5124d0ce64242d792a3" }, "downloads": -1, "filename": "pylikwid-0.2.6.tar.gz", "has_sig": false, "md5_digest": "83f0fd3bf8ce1ae94b50a7b6be99a5dd", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 31075, "upload_time": "2018-05-29T13:22:55", "url": "https://files.pythonhosted.org/packages/97/ae/0e6a77c122fe82dac4f987995924831ecdac322a7bd7e48dd93d00dee4d4/pylikwid-0.2.6.tar.gz" } ], "0.2.7": [ { "comment_text": "", "digests": { "md5": "8368a3061276e335fdbbd1623bd1b03e", "sha256": "ff3fd9af97320bff10da920b1330ed0a4c4b71d933878dcb75a0ea56fe726b7e" }, "downloads": -1, "filename": "pylikwid-0.2.7.tar.gz", "has_sig": false, "md5_digest": "8368a3061276e335fdbbd1623bd1b03e", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 31038, "upload_time": "2018-06-04T10:17:47", "url": "https://files.pythonhosted.org/packages/c1/6f/9b74caea82019cb569a3c14be2e0bb40e639a3532f210bded31e503f006c/pylikwid-0.2.7.tar.gz" } ], "0.2.8": [ { "comment_text": "", "digests": { "md5": "1b8b9d66c9b6c28ff7aef318498f93aa", "sha256": "9744a2cbbaed880db024c8351158ab1b6febd2d081640771ebe6907ed2b5c652" }, "downloads": -1, "filename": "pylikwid-0.2.8.tar.gz", "has_sig": false, "md5_digest": "1b8b9d66c9b6c28ff7aef318498f93aa", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 31823, "upload_time": "2018-06-25T18:31:49", "url": "https://files.pythonhosted.org/packages/8a/47/b5115b439b584b59a907438c185440e84e40f4ee2adf6468096c3a039fdc/pylikwid-0.2.8.tar.gz" } ], "0.2.9": [ { "comment_text": "", "digests": { "md5": "465826dd047ca6ea5a5fceb2c4d04a05", "sha256": "5da656832de02046bb99b6f26c37f78f124313c27958540ac43d6a9787bf9d9f" }, "downloads": -1, "filename": "pylikwid-0.2.9.tar.gz", "has_sig": false, "md5_digest": "465826dd047ca6ea5a5fceb2c4d04a05", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 31835, "upload_time": "2018-06-27T08:44:27", "url": "https://files.pythonhosted.org/packages/5d/45/28576fc23f7cf3fb2c10353cfea5d6513e8b6fecb6cbb35ce231c6c513cd/pylikwid-0.2.9.tar.gz" } ], "0.3.0": [ { "comment_text": "", "digests": { "md5": "656e9a658c514764fa1b8b632c861eb4", "sha256": "bf940c28c7ea81512fa72d73419f2b2bb837b6c612e94b3ecb17013d8a1f747a" }, "downloads": -1, "filename": "pylikwid-0.3.0.tar.gz", "has_sig": false, "md5_digest": "656e9a658c514764fa1b8b632c861eb4", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 32065, "upload_time": "2019-04-24T14:14:59", "url": "https://files.pythonhosted.org/packages/bf/3b/93e49b5e691e130445cc148057cba5d064ea940581c14e770cf0bef7a78a/pylikwid-0.3.0.tar.gz" } ], "0.3.1": [ { "comment_text": "", "digests": { "md5": "4718bc68e3966647fefcc863706f63f2", "sha256": "ac6ada2dc0856a89a7acee0ef536b34259cd33cca4b5af3eff33c679be623fd0" }, "downloads": -1, "filename": "pylikwid-0.3.1.tar.gz", "has_sig": false, "md5_digest": "4718bc68e3966647fefcc863706f63f2", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 32079, "upload_time": "2019-04-24T14:56:16", "url": "https://files.pythonhosted.org/packages/ac/83/917a50fad8a0bfcc5e684cecf0633a3ba5be7a72ffb97b9b9c61c4ca7c7c/pylikwid-0.3.1.tar.gz" } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "4718bc68e3966647fefcc863706f63f2", "sha256": "ac6ada2dc0856a89a7acee0ef536b34259cd33cca4b5af3eff33c679be623fd0" }, "downloads": -1, "filename": "pylikwid-0.3.1.tar.gz", "has_sig": false, "md5_digest": "4718bc68e3966647fefcc863706f63f2", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 32079, "upload_time": "2019-04-24T14:56:16", "url": "https://files.pythonhosted.org/packages/ac/83/917a50fad8a0bfcc5e684cecf0633a3ba5be7a72ffb97b9b9c61c4ca7c7c/pylikwid-0.3.1.tar.gz" } ] }